@kubb/adapter-oas 5.0.0-beta.68 → 5.0.0-beta.69

package/dist/index.cjs

@@ -612,168 +612,6 @@ async function validateDocument(document, { throwOnError = false } = {}) {
 	}
 }
 //#endregion
-//#region src/dedupe.ts
-/**
-* Minimum occurrences before a shape is deduplicated.
-*/
-const MIN_OCCURRENCES = 2;
-/**
-* Builds the shared `ref` replacement for a duplicate occurrence, carrying the
-* usage-slot and documentation fields that are not part of the shared type.
-*/
-function createRefNode(node, target) {
-	return _kubb_core.ast.factory.createSchema({
-		type: "ref",
-		name: target.name,
-		ref: target.ref,
-		optional: node.optional,
-		nullish: node.nullish,
-		readOnly: node.readOnly,
-		writeOnly: node.writeOnly,
-		deprecated: node.deprecated,
-		description: node.description,
-		default: node.default,
-		examples: node.examples
-	});
-}
-/**
-* Strips usage-slot flags from an extracted definition and applies its name.
-* A standalone definition is never optional, so `optional`/`nullish` are cleared.
-*/
-function cleanDefinition(node, name) {
-	return {
-		...node,
-		name,
-		optional: void 0,
-		nullish: void 0
-	};
-}
-/**
-* Returns `true` when a node is eligible for deduplication. Only enums and objects qualify, and
-* object shapes that take part in a circular chain are rejected so recursive structures are not
-* extracted (which would break the cycle).
-*/
-function isCandidate(node, circularSchemas) {
-	if (node.type === "enum") return true;
-	if (node.type !== "object") return false;
-	if (node.name && circularSchemas.has(node.name)) return false;
-	return !(0, _kubb_ast_utils.containsCircularRef)(node, { circularSchemas });
-}
-/**
-* Produces the name for an inline shape with no existing named component, resolving
-* collisions against `usedNames`. Returns `null` for an unnamed shape, which stays inline.
-*/
-function nameFor(node, usedNames) {
-	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;
-}
-/**
-* Scans a forest of schema and operation nodes and produces a {@link Plan}.
-*
-* A shape that occurs at least {@link MIN_OCCURRENCES} times is deduplicated: if any occurrence is
-* a named top-level schema, the first one becomes the target (so other top-level duplicates and
-* inline copies turn into references to it). Other top-level names with the same content are
-* recorded as aliases. Otherwise a new definition is extracted using {@link nameFor}. The returned
-* plan rewrites nodes against those decisions.
-*
-* @example
-* ```ts
-* const dedupePlan = plan([...schemaNodes, ...operationNodes], { circularSchemas, usedNames })
-* ```
-*/
-function plan(roots, context) {
-	const { circularSchemas, usedNames } = context;
-	const topLevelNodes = /* @__PURE__ */ new Set();
-	const groups = /* @__PURE__ */ new Map();
-	for (const root of roots) {
-		if (root.kind === "Schema") topLevelNodes.add(root);
-		for (const schemaNode of _kubb_core.ast.collect(root, { schema: (node) => node })) {
-			if (!isCandidate(schemaNode, circularSchemas)) continue;
-			const signature = _kubb_core.ast.signatureOf(schemaNode);
-			const isTopLevel = topLevelNodes.has(schemaNode) && !!schemaNode.name;
-			const group = groups.get(signature);
-			if (group) {
-				group.count++;
-				if (isTopLevel) group.topLevelNames.push(schemaNode.name);
-			} else groups.set(signature, {
-				count: 1,
-				representative: schemaNode,
-				topLevelNames: isTopLevel ? [schemaNode.name] : []
-			});
-		}
-	}
-	const bySignature = /* @__PURE__ */ new Map();
-	const byName = /* @__PURE__ */ new Map();
-	const pendingExtractions = [];
-	for (const [signature, group] of groups) {
-		if (group.count < MIN_OCCURRENCES) continue;
-		const [firstName, ...duplicateNames] = group.topLevelNames;
-		if (firstName) {
-			const target = {
-				name: firstName,
-				ref: `${SCHEMA_REF_PREFIX}${firstName}`
-			};
-			bySignature.set(signature, target);
-			for (const duplicate of duplicateNames) byName.set(duplicate, target);
-			continue;
-		}
-		const name = nameFor(group.representative, usedNames);
-		if (!name) continue;
-		bySignature.set(signature, {
-			name,
-			ref: `${SCHEMA_REF_PREFIX}${name}`
-		});
-		pendingExtractions.push({
-			name,
-			representative: group.representative
-		});
-	}
-	function rewrite(node, skipRootMatch) {
-		if (bySignature.size === 0 && byName.size === 0) return node;
-		const root = node;
-		return _kubb_core.ast.transform(node, { schema(schemaNode) {
-			if (schemaNode.type === "ref") {
-				const refName = schemaNode.ref ? (0, _kubb_ast_utils.extractRefName)(schemaNode.ref) : schemaNode.name;
-				const target = refName ? byName.get(refName) : void 0;
-				return target ? {
-					...schemaNode,
-					name: target.name,
-					ref: target.ref
-				} : void 0;
-			}
-			if (skipRootMatch && schemaNode === root) return void 0;
-			const target = bySignature.get(_kubb_core.ast.signatureOf(schemaNode));
-			if (!target) return void 0;
-			return createRefNode(schemaNode, target);
-		} });
-	}
-	return {
-		extracted: pendingExtractions.map(({ name, representative }) => cleanDefinition(rewrite(representative, true), name)),
-		apply(node) {
-			return rewrite(node, false);
-		},
-		applyTopLevel(node) {
-			const target = bySignature.get(_kubb_core.ast.signatureOf(node));
-			if (target && target.name !== node.name) return _kubb_core.ast.factory.createSchema({
-				type: "ref",
-				name: node.name ?? null,
-				ref: target.ref,
-				description: node.description,
-				deprecated: node.deprecated
-			});
-			return rewrite(node, true);
-		},
-		isAlias(name) {
-			return byName.has(name);
-		}
-	};
-}
-//#endregion
 //#region src/guards.ts
 /**
 * Returns `true` when a schema should be treated as nullable.
@@ -915,8 +753,7 @@ const oasDialect = _kubb_core.ast.defineDialect({
 		isDiscriminator,
 		isBinary: (schema) => schema.type === "string" && schema.contentMediaType === "application/octet-stream",
 		resolveRef
-	},
-	dedupe: { plan }
+	}
 });
 //#endregion
 //#region src/discriminator.ts
@@ -2498,6 +2335,53 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 	};
 }
 //#endregion
+//#region src/promoteEnums.ts
+/**
+* Collects inline enums to lift to the top level, keyed by the name the parser derived for them
+* (e.g. `PetStatusEnum`). An enum already defined as a top-level component is left as-is, and a
+* name that recurs maps to the first definition so each name yields one shared type.
+*/
+function collectInlineEnums(roots, topLevelNames) {
+	const promoted = /* @__PURE__ */ new Map();
+	for (const root of roots) {
+		const isSchemaRoot = root.kind === "Schema";
+		for (const node of _kubb_core.ast.collect(root, { schema: (schemaNode) => schemaNode })) {
+			if (node.type !== "enum" || !node.name) continue;
+			if (isSchemaRoot && node === root) continue;
+			if (topLevelNames.has(node.name)) continue;
+			if (!promoted.has(node.name)) promoted.set(node.name, {
+				...node,
+				optional: void 0,
+				nullish: void 0
+			});
+		}
+	}
+	return promoted;
+}
+/**
+* Replaces every promoted inline enum in `node` with a `ref` to its lifted definition, keeping the
+* occurrence's usage-slot and documentation fields.
+*/
+function refPromotedEnums(node, promoted) {
+	if (promoted.size === 0) return node;
+	return _kubb_core.ast.transform(node, { schema(schemaNode) {
+		if (schemaNode.type !== "enum" || !schemaNode.name || !promoted.has(schemaNode.name)) return void 0;
+		return _kubb_core.ast.factory.createSchema({
+			type: "ref",
+			name: schemaNode.name,
+			ref: `${SCHEMA_REF_PREFIX}${schemaNode.name}`,
+			optional: schemaNode.optional,
+			nullish: schemaNode.nullish,
+			readOnly: schemaNode.readOnly,
+			writeOnly: schemaNode.writeOnly,
+			deprecated: schemaNode.deprecated,
+			description: schemaNode.description,
+			default: schemaNode.default,
+			examples: schemaNode.examples
+		});
+	} });
+}
+//#endregion
 //#region src/schemaDiagnostics.ts
 /**
 * Reports the advisory diagnostics (`KUBB_UNSUPPORTED_FORMAT`, `KUBB_DEPRECATED`) for one
@@ -2555,20 +2439,21 @@ function visit(node, pointer) {
 //#endregion
 //#region src/stream.ts
 /**
-* Reads the server URL from the document's `servers` array at `serverIndex`,
-* interpolating any `serverVariables` into the URL template.
+* Reads the server URL from the document's `servers` array at `server.index`,
+* interpolating any `server.variables` into the URL template.
 *
-* Returns `null` when `serverIndex` is omitted or out of range.
+* Returns `null` when `server.index` is omitted or out of range.
 *
 * @example Resolve the first server
-* `resolveBaseUrl({ document, serverIndex: 0 })`
+* `resolveBaseUrl({ document, server: { index: 0 } })`
 *
 * @example Override a path variable
-* `resolveBaseUrl({ document, serverIndex: 0, serverVariables: { version: 'v2' } })`
+* `resolveBaseUrl({ document, server: { index: 0, variables: { version: 'v2' } } })`
 */
-function resolveBaseUrl({ document, serverIndex, serverVariables }) {
-	const server = serverIndex !== void 0 ? document.servers?.at(serverIndex) : void 0;
-	return server?.url ? resolveServerUrl(server, serverVariables) : null;
+function resolveBaseUrl({ document, server }) {
+	const index = server?.index;
+	const entry = index !== void 0 ? document.servers?.at(index) : void 0;
+	return entry?.url ? resolveServerUrl(entry, server?.variables) : null;
 }
 /**
 * Parses every schema once to build the lookup structures that streaming needs upfront.
@@ -2591,11 +2476,11 @@ function resolveBaseUrl({ document, serverIndex, serverVariables }) {
 *   schemas,
 *   parseSchema,
 *   parserOptions,
-*   discriminator: 'strict',
+*   discriminator: 'preserve',
 * })
 * ```
 */
-function preScan({ schemas, parseSchema, parseOperation, document, parserOptions, discriminator, dedupe }) {
+function preScan({ schemas, parseSchema, parseOperation, document, parserOptions, discriminator, enums = "inline" }) {
 	const allNodes = [];
 	const refAliasMap = /* @__PURE__ */ new Map();
 	const enumNames = [];
@@ -2612,31 +2497,26 @@ function preScan({ schemas, parseSchema, parseOperation, document, parserOptions
 		});
 		if (node.type === "ref" && node.name && node.name !== name) refAliasMap.set(name, node);
 		if (_kubb_core.ast.narrowSchema(node, _kubb_core.ast.schemaTypes.enum) && node.name) enumNames.push(node.name);
-		if (discriminator === "inherit" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
+		if (discriminator === "propagate" && (schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) discriminatorParentNodes.push(node);
 	}
 	const circularNames = [...(0, _kubb_ast_utils.findCircularSchemas)(allNodes)];
 	const discriminatorChildMap = discriminatorParentNodes.length > 0 ? buildDiscriminatorChildMap(discriminatorParentNodes) : null;
-	let dedupePlan = null;
-	if (dedupe) {
+	let promotedEnums = null;
+	if (enums === "root" && document && parseOperation) {
 		const operationNodes = [];
 		for (const operation of getOperations(document)) {
 			const operationNode = parseOperation(parserOptions, operation);
 			if (operationNode) operationNodes.push(operationNode);
 		}
-		const circularSchemas = new Set(circularNames);
-		const usedNames = new Set(Object.keys(schemas));
-		dedupePlan = oasDialect.dedupe.plan([...allNodes, ...operationNodes], {
-			circularSchemas,
-			usedNames
-		});
-		for (const definition of dedupePlan.extracted) if (definition.type === "enum" && definition.name) enumNames.push(definition.name);
+		promotedEnums = collectInlineEnums([...allNodes, ...operationNodes], new Set(Object.keys(schemas)));
+		for (const name of promotedEnums.keys()) enumNames.push(name);
 	}
 	return {
 		refAliasMap,
-		enumNames: dedupePlan ? enumNames.filter((name) => !dedupePlan.isAlias(name)) : enumNames,
+		enumNames,
 		circularNames,
 		discriminatorChildMap,
-		dedupePlan
+		promotedEnums
 	};
 }
 /**
@@ -2657,12 +2537,11 @@ function preScan({ schemas, parseSchema, parseOperation, document, parserOptions
 * }
 * ```
 */
-function createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, dedupePlan, meta }) {
+function createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, promotedEnums, meta }) {
 	const schemasIterable = { [Symbol.asyncIterator]() {
 		return (async function* () {
-			if (dedupePlan) for (const definition of dedupePlan.extracted) yield definition;
+			if (promotedEnums) for (const definition of promotedEnums.values()) yield definition;
 			for (const [name, schema] of Object.entries(schemas)) {
-				if (dedupePlan?.isAlias(name)) continue;
 				const alias = refAliasMap.get(name);
 				if (alias?.name && schemas[alias.name]) {
 					const aliasNode = {
@@ -2672,7 +2551,7 @@ function createInputStream({ schemas, parseSchema, parseOperation, document, par
 						}, parserOptions),
 						name
 					};
-					yield dedupePlan ? dedupePlan.applyTopLevel(aliasNode) : aliasNode;
+					yield promotedEnums ? refPromotedEnums(aliasNode, promotedEnums) : aliasNode;
 					continue;
 				}
 				const parsed = parseSchema({
@@ -2680,7 +2559,7 @@ function createInputStream({ schemas, parseSchema, parseOperation, document, par
 					name
 				}, parserOptions);
 				const node = discriminatorChildMap?.get(name) ? patchDiscriminatorNode(parsed, discriminatorChildMap.get(name)) : parsed;
-				yield dedupePlan ? dedupePlan.applyTopLevel(node) : node;
+				yield promotedEnums ? refPromotedEnums(node, promotedEnums) : node;
 			}
 		})();
 	} };
@@ -2688,7 +2567,7 @@ function createInputStream({ schemas, parseSchema, parseOperation, document, par
 		return (async function* () {
 			for (const operation of getOperations(document)) {
 				const node = parseOperation(parserOptions, operation);
-				if (node) yield dedupePlan ? dedupePlan.apply(node) : node;
+				if (node) yield promotedEnums ? refPromotedEnums(node, promotedEnums) : node;
 			}
 		})();
 	} };
@@ -2724,8 +2603,8 @@ const adapterOasName = "oas";
 *   input: { path: './petStore.yaml' },
 *   output: { path: './src/gen' },
 *   adapter: adapterOas({
-*     serverIndex: 0,
-*     discriminator: 'inherit',
+*     server: { index: 0 },
+*     discriminator: 'propagate',
 *     dateType: 'date',
 *   }),
 *   plugins: [pluginTs()],
@@ -2733,7 +2612,7 @@ const adapterOasName = "oas";
 * ```
 */
 const adapterOas = (0, _kubb_core.createAdapter)((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 { validate = true, contentType, server, discriminator = "preserve", enums = "inline", 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,
@@ -2791,7 +2670,7 @@ const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 			document,
 			parserOptions,
 			discriminator,
-			dedupe
+			enums
 		});
 		preScanCache.set(document, result);
 		return result;
@@ -2800,7 +2679,7 @@ const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 		const document = await ensureDocument(source);
 		const schemas = await ensureSchemas(document);
 		const { parseSchema, parseOperation } = ensureSchemaParser(document);
-		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan } = ensurePreScan(document, schemas, parseSchema, parseOperation);
+		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, promotedEnums } = ensurePreScan(document, schemas, parseSchema, parseOperation);
 		return createInputStream({
 			schemas,
 			parseSchema,
@@ -2809,15 +2688,14 @@ const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 			parserOptions,
 			refAliasMap,
 			discriminatorChildMap,
-			dedupePlan,
+			promotedEnums,
 			meta: {
 				title: document.info?.title,
 				description: document.info?.description,
 				version: document.info?.version,
 				baseURL: resolveBaseUrl({
 					document,
-					serverIndex,
-					serverVariables
+					server
 				}),
 				circularNames,
 				enumNames
@@ -2830,10 +2708,9 @@ const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 			return {
 				validate,
 				contentType,
-				serverIndex,
-				serverVariables,
+				server,
 				discriminator,
-				dedupe,
+				enums,
 				dateType,
 				integerType,
 				unknownType,