@kubb/adapter-oas 5.0.0-beta.37 → 5.0.0-beta.39

package/dist/index.js

@@ -1,13 +1,145 @@
 import "./chunk-C0LytTxp.js";
-import { access } from "node:fs/promises";
-import path from "node:path";
-import { DiagnosticError, Diagnostics, ast, createAdapter, diagnosticCode } from "@kubb/core";
+import { Diagnostics, ast, createAdapter } from "@kubb/core";
 import BaseOas from "oas";
+import path from "node:path";
+import { access } from "node:fs/promises";
 import { bundle, loadConfig } from "@redocly/openapi-core";
 import OASNormalize from "oas-normalize";
 import swagger2openapi from "swagger2openapi";
 import { isRef } from "oas/types";
 import { matchesMimeType } from "oas/utils";
+//#region src/constants.ts
+/**
+* Default parser options applied when no explicit options are provided.
+*
+* @example
+* ```ts
+* import { DEFAULT_PARSER_OPTIONS } from '@kubb/adapter-oas'
+*
+* const parser = createOasParser(oas)
+* const root = parser.parse({ ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
+* ```
+*/
+const DEFAULT_PARSER_OPTIONS = {
+	dateType: "string",
+	integerType: "bigint",
+	unknownType: "any",
+	emptySchemaType: "any",
+	enumSuffix: "enum"
+};
+/**
+* JSON-Pointer prefix for schemas declared under `components.schemas` in an OpenAPI document.
+*
+* Used when building or parsing `$ref` strings.
+*
+* @example
+* ```ts
+* `${SCHEMA_REF_PREFIX}Pet` // '#/components/schemas/Pet'
+* ```
+*/
+const SCHEMA_REF_PREFIX = "#/components/schemas/";
+/**
+* OpenAPI version string written into the stub document created during multi-spec merges.
+*/
+const MERGE_OPENAPI_VERSION = "3.0.0";
+/**
+* Fallback `info.title` placed in the stub document when merging multiple API files.
+*/
+const MERGE_DEFAULT_TITLE = "Merged API";
+/**
+* Fallback `info.version` placed in the stub document when merging multiple API files.
+*/
+const MERGE_DEFAULT_VERSION = "1.0.0";
+/**
+* Set of JSON Schema keywords that prevent a schema fragment from being inlined during `allOf` flattening.
+*
+* A fragment that contains any of these keys carries structural meaning of its own and must stay as a separate
+* intersection member rather than being merged into the parent.
+*
+* @example
+* ```ts
+* import { structuralKeys } from '@kubb/adapter-oas'
+*
+* const isStructural = Object.keys(fragment).some((key) => structuralKeys.has(key))
+* // true when fragment has e.g. 'properties' or 'oneOf'
+* ```
+*/
+const structuralKeys = new Set([
+	"properties",
+	"items",
+	"additionalProperties",
+	"oneOf",
+	"anyOf",
+	"allOf",
+	"not"
+]);
+/**
+* Static map from OAS `format` strings to Kubb `SchemaType` values.
+*
+* Only formats whose AST type differs from the OAS `type` field appear here.
+* Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled separately
+* in the parser. `ipv4` and `ipv6` map to their own dedicated schema types; `hostname` and
+* `idn-hostname` map to `'url'` as the closest generic string-format type.
+*
+* @example
+* ```ts
+* import { formatMap } from '@kubb/adapter-oas'
+*
+* formatMap['uuid']   // 'uuid'
+* formatMap['binary'] // 'blob'
+* formatMap['float']  // 'number'
+* ```
+*/
+/**
+* Formats `convertFormat` maps to a dedicated type without going through `formatMap`:
+* `int64` and the date/time family. Keep this in sync with the `convertFormat`
+* special-cases in `parser.ts`. `isHandledFormat` reads it so the
+* `KUBB_UNSUPPORTED_FORMAT` diagnostic and the parser agree on what is handled.
+*/
+const specialCasedFormats = new Set([
+	"int64",
+	"date-time",
+	"date",
+	"time"
+]);
+const formatMap = {
+	uuid: "uuid",
+	email: "email",
+	"idn-email": "email",
+	uri: "url",
+	"uri-reference": "url",
+	url: "url",
+	ipv4: "ipv4",
+	ipv6: "ipv6",
+	hostname: "url",
+	"idn-hostname": "url",
+	binary: "blob",
+	byte: "blob",
+	int32: "integer",
+	float: "number",
+	double: "number"
+};
+/**
+* Vendor extension keys that attach human-readable labels to enum values, checked in priority order.
+*
+* @example
+* ```ts
+* import { enumExtensionKeys } from '@kubb/adapter-oas'
+*
+* const key = enumExtensionKeys.find((k) => k in schema) // 'x-enumNames' | 'x-enum-varnames' | undefined
+* ```
+*/
+const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
+/**
+* Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
+* Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
+*/
+const typeOptionMap = new Map([
+	["any", ast.schemaTypes.any],
+	["unknown", ast.schemaTypes.unknown],
+	["void", ast.schemaTypes.void]
+]);
+//#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -123,30 +255,6 @@ function mergeDeep(target, source) {
 	return result;
 }
 //#endregion
-//#region ../../internals/utils/src/promise.ts
-/**
-* Returns a wrapper that caches the result of the first invocation and replays
-* it for every subsequent call, ignoring later arguments.
-*
-* Works for sync and async factories — for async, the cached value is the
-* promise itself, so concurrent callers share one in-flight execution and
-* cannot race each other.
-*
-* @example
-* ```ts
-* const loadDocument = once(async (path: string) => parse(await readFile(path)))
-* const a = loadDocument('./a.yaml') // parses
-* const b = loadDocument('./b.yaml') // returns the cached promise from the first call
-* ```
-*/
-function once(factory) {
-	let cache;
-	return (...args) => {
-		if (!cache) cache = { value: factory(...args) };
-		return cache.value;
-	};
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -397,138 +505,6 @@ var URLPath = class {
 	}
 };
 //#endregion
-//#region src/constants.ts
-/**
-* Default parser options applied when no explicit options are provided.
-*
-* @example
-* ```ts
-* import { DEFAULT_PARSER_OPTIONS } from '@kubb/adapter-oas'
-*
-* const parser = createOasParser(oas)
-* const root = parser.parse({ ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
-* ```
-*/
-const DEFAULT_PARSER_OPTIONS = {
-	dateType: "string",
-	integerType: "bigint",
-	unknownType: "any",
-	emptySchemaType: "any",
-	enumSuffix: "enum"
-};
-/**
-* JSON-Pointer prefix for schemas declared under `components.schemas` in an OpenAPI document.
-*
-* Used when building or parsing `$ref` strings.
-*
-* @example
-* ```ts
-* `${SCHEMA_REF_PREFIX}Pet` // '#/components/schemas/Pet'
-* ```
-*/
-const SCHEMA_REF_PREFIX = "#/components/schemas/";
-/**
-* OpenAPI version string written into the stub document created during multi-spec merges.
-*/
-const MERGE_OPENAPI_VERSION = "3.0.0";
-/**
-* Fallback `info.title` placed in the stub document when merging multiple API files.
-*/
-const MERGE_DEFAULT_TITLE = "Merged API";
-/**
-* Fallback `info.version` placed in the stub document when merging multiple API files.
-*/
-const MERGE_DEFAULT_VERSION = "1.0.0";
-/**
-* Set of JSON Schema keywords that prevent a schema fragment from being inlined during `allOf` flattening.
-*
-* A fragment that contains any of these keys carries structural meaning of its own and must stay as a separate
-* intersection member rather than being merged into the parent.
-*
-* @example
-* ```ts
-* import { structuralKeys } from '@kubb/adapter-oas'
-*
-* const isStructural = Object.keys(fragment).some((key) => structuralKeys.has(key))
-* // true when fragment has e.g. 'properties' or 'oneOf'
-* ```
-*/
-const structuralKeys = new Set([
-	"properties",
-	"items",
-	"additionalProperties",
-	"oneOf",
-	"anyOf",
-	"allOf",
-	"not"
-]);
-/**
-* Static map from OAS `format` strings to Kubb `SchemaType` values.
-*
-* Only formats whose AST type differs from the OAS `type` field appear here.
-* Formats that depend on runtime options (`int64`, `date-time`, `date`, `time`) are handled separately
-* in the parser. `ipv4` and `ipv6` map to their own dedicated schema types; `hostname` and
-* `idn-hostname` map to `'url'` as the closest generic string-format type.
-*
-* @example
-* ```ts
-* import { formatMap } from '@kubb/adapter-oas'
-*
-* formatMap['uuid']   // 'uuid'
-* formatMap['binary'] // 'blob'
-* formatMap['float']  // 'number'
-* ```
-*/
-/**
-* Formats `convertFormat` maps to a dedicated type without going through `formatMap`:
-* `int64` and the date/time family. Keep this in sync with the `convertFormat`
-* special-cases in `parser.ts`. `isHandledFormat` reads it so the
-* `KUBB_UNSUPPORTED_FORMAT` diagnostic and the parser agree on what is handled.
-*/
-const specialCasedFormats = new Set([
-	"int64",
-	"date-time",
-	"date",
-	"time"
-]);
-const formatMap = {
-	uuid: "uuid",
-	email: "email",
-	"idn-email": "email",
-	uri: "url",
-	"uri-reference": "url",
-	url: "url",
-	ipv4: "ipv4",
-	ipv6: "ipv6",
-	hostname: "url",
-	"idn-hostname": "url",
-	binary: "blob",
-	byte: "blob",
-	int32: "integer",
-	float: "number",
-	double: "number"
-};
-/**
-* Vendor extension keys that attach human-readable labels to enum values, checked in priority order.
-*
-* @example
-* ```ts
-* import { enumExtensionKeys } from '@kubb/adapter-oas'
-*
-* const key = enumExtensionKeys.find((k) => k in schema) // 'x-enumNames' | 'x-enum-varnames' | undefined
-* ```
-*/
-const enumExtensionKeys = ["x-enumNames", "x-enum-varnames"];
-/**
-* Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
-* Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
-*/
-const typeOptionMap = new Map([
-	["any", ast.schemaTypes.any],
-	["unknown", ast.schemaTypes.unknown],
-	["void", ast.schemaTypes.void]
-]);
-//#endregion
 //#region src/guards.ts
 /**
 * Returns `true` when `doc` is a Swagger 2.0 document (no `openapi` key).
@@ -638,8 +614,8 @@ async function mergeDocuments(pathOrApi) {
 		enablePaths: false,
 		canBundle: false
 	})));
-	if (documents.length === 0) throw new DiagnosticError({
-		code: diagnosticCode.inputRequired,
+	if (documents.length === 0) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputRequired,
 		severity: "error",
 		message: "No OAS documents were provided for merging.",
 		help: "Pass at least one path or document to `input.path`.",
@@ -688,8 +664,8 @@ async function parseFromConfig(source) {
 */
 async function assertInputExists(input) {
 	if (new URLPath(input).isURL) return;
-	if (!await exists(input)) throw new DiagnosticError({
-		code: diagnosticCode.inputNotFound,
+	if (!await exists(input)) throw new Diagnostics.Error({
+		code: Diagnostics.code.inputNotFound,
 		severity: "error",
 		message: `Cannot read the file set in \`input.path\` (or via \`kubb generate PATH\`): ${input}`,
 		help: "Check that the path exists and is readable, then set it in `input.path` or pass it as `kubb generate PATH`.",
@@ -743,7 +719,7 @@ function resolveRef(document, $ref) {
 	const current = $ref.split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document);
 	if (!current) {
 		const diagnostic = {
-			code: diagnosticCode.refNotFound,
+			code: Diagnostics.code.refNotFound,
 			severity: "error",
 			message: `Could not find a definition for ${origRef}.`,
 			help: "Add the schema under `components.schemas`, or fix the `$ref`. Run `kubb validate` to check the spec.",
@@ -753,7 +729,7 @@ function resolveRef(document, $ref) {
 				ref: origRef
 			}
 		};
-		Diagnostics.report(diagnostic);
+		if (!Diagnostics.report(diagnostic)) throw new Diagnostics.Error(diagnostic);
 		return null;
 	}
 	docCache.set($ref, current);
@@ -830,8 +806,8 @@ function resolveServerUrl(server, overrides) {
 	for (const [key, variable] of Object.entries(server.variables)) {
 		const value = overrides?.[key] ?? (variable.default != null ? String(variable.default) : void 0);
 		if (value === void 0) continue;
-		if (variable.enum?.length && !variable.enum.some((e) => String(e) === value)) throw new DiagnosticError({
-			code: diagnosticCode.invalidServerVariable,
+		if (variable.enum?.length && !variable.enum.some((e) => String(e) === value)) throw new Diagnostics.Error({
+			code: Diagnostics.code.invalidServerVariable,
 			severity: "error",
 			message: `Invalid server variable value '${value}' for '${key}' when resolving ${server.url}. Valid values are: ${variable.enum.join(", ")}.`,
 			help: `Use one of the allowed enum values, or drop the enum on the '${key}' server variable.`,
@@ -2162,11 +2138,18 @@ function patchDiscriminatorNode(node, entry) {
 * no-op outside one, and repeats are deduped by the build.
 */
 function reportSchemaDiagnostics({ node, name }) {
-	visit(node, `#/components/schemas/${name}`);
+	visit(node, `#/components/schemas/${escapePointerToken(name)}`);
+}
+/**
+* Escapes a single JSON pointer reference token per RFC 6901 (`~` → `~0`, `/` → `~1`), so a
+* property name with those characters maps to a distinct pointer instead of colliding in the dedupe.
+*/
+function escapePointerToken(token) {
+	return token.replace(/~/g, "~0").replace(/\//g, "~1");
 }
 function visit(node, pointer) {
 	if (node.deprecated) Diagnostics.report({
-		code: diagnosticCode.deprecated,
+		code: Diagnostics.code.deprecated,
 		severity: "info",
 		message: "This schema is marked as deprecated.",
 		location: {
@@ -2175,7 +2158,7 @@ function visit(node, pointer) {
 		}
 	});
 	if (typeof node.format === "string" && !isHandledFormat(node.format)) Diagnostics.report({
-		code: diagnosticCode.unsupportedFormat,
+		code: Diagnostics.code.unsupportedFormat,
 		severity: "warning",
 		message: `Kubb does not map the format "${node.format}" to a specific type, so it falls back to the base type.`,
 		help: `Use a format Kubb supports, or handle "${node.format}" with a custom parser or plugin.`,
@@ -2185,15 +2168,19 @@ function visit(node, pointer) {
 		}
 	});
 	if (node.type === "object") {
-		for (const property of node.properties) visit(property.schema, `${pointer}/properties/${property.name}`);
+		for (const property of node.properties) visit(property.schema, `${pointer}/properties/${escapePointerToken(property.name)}`);
 		if (node.additionalProperties && typeof node.additionalProperties === "object") visit(node.additionalProperties, `${pointer}/additionalProperties`);
 		return;
 	}
-	if (node.type === "array" || node.type === "tuple") {
+	if (node.type === "array") {
 		for (const item of node.items ?? []) visit(item, `${pointer}/items`);
 		return;
 	}
-	if (node.type === "union" || node.type === "intersection") for (const member of node.members ?? []) visit(member, pointer);
+	if (node.type === "tuple") {
+		for (const [index, item] of (node.items ?? []).entries()) visit(item, `${pointer}/items/${index}`);
+		return;
+	}
+	if (node.type === "union" || node.type === "intersection") for (const [index, member] of (node.members ?? []).entries()) visit(member, `${pointer}/members/${index}`);
 }
 //#endregion
 //#region src/stream.ts
@@ -2423,37 +2410,72 @@ const adapterOas = createAdapter((options) => {
 	};
 	let nameMapping = /* @__PURE__ */ new Map();
 	let parsedDocument = null;
-	const ensureDocument = once(async (source) => {
-		const fresh = await parseFromConfig(source);
-		if (validate) await validateDocument(fresh);
-		parsedDocument = fresh;
-		return fresh;
-	});
-	const ensureSchemas = once(async (document) => {
-		const result = getSchemas(document, { contentType });
-		nameMapping = result.nameMapping;
-		return result.schemas;
-	});
-	const ensureBaseOas = once((document) => new BaseOas(document));
-	const ensureSchemaParser = once((document) => createSchemaParser({
-		document,
-		contentType
-	}));
-	const ensurePreScan = once((schemas, parseSchema, parseOperation, baseOas) => preScan({
-		schemas,
-		parseSchema,
-		parseOperation,
-		baseOas,
-		parserOptions,
-		discriminator,
-		dedupe
-	}));
+	const documentCache = /* @__PURE__ */ new WeakMap();
+	const schemasCache = /* @__PURE__ */ new WeakMap();
+	const baseOasCache = /* @__PURE__ */ new WeakMap();
+	const schemaParserCache = /* @__PURE__ */ new WeakMap();
+	const preScanCache = /* @__PURE__ */ new WeakMap();
+	function ensureDocument(source) {
+		const cached = documentCache.get(source);
+		if (cached) return cached;
+		const promise = (async () => {
+			const fresh = await parseFromConfig(source);
+			if (validate) await validateDocument(fresh);
+			parsedDocument = fresh;
+			return fresh;
+		})();
+		documentCache.set(source, promise);
+		return promise;
+	}
+	function ensureSchemas(document) {
+		const cached = schemasCache.get(document);
+		if (cached) return cached;
+		const promise = Promise.resolve().then(() => {
+			const result = getSchemas(document, { contentType });
+			nameMapping = result.nameMapping;
+			return result.schemas;
+		});
+		schemasCache.set(document, promise);
+		return promise;
+	}
+	function ensureBaseOas(document) {
+		const cached = baseOasCache.get(document);
+		if (cached) return cached;
+		const baseOas = new BaseOas(document);
+		baseOasCache.set(document, baseOas);
+		return baseOas;
+	}
+	function ensureSchemaParser(document) {
+		const cached = schemaParserCache.get(document);
+		if (cached) return cached;
+		const parser = createSchemaParser({
+			document,
+			contentType
+		});
+		schemaParserCache.set(document, parser);
+		return parser;
+	}
+	function ensurePreScan(document, schemas, parseSchema, parseOperation, baseOas) {
+		const cached = preScanCache.get(document);
+		if (cached) return cached;
+		const result = preScan({
+			schemas,
+			parseSchema,
+			parseOperation,
+			baseOas,
+			parserOptions,
+			discriminator,
+			dedupe
+		});
+		preScanCache.set(document, result);
+		return result;
+	}
 	async function createStream(source) {
 		const document = await ensureDocument(source);
 		const schemas = await ensureSchemas(document);
 		const { parseSchema, parseOperation } = ensureSchemaParser(document);
 		const baseOas = ensureBaseOas(document);
-		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan } = ensurePreScan(schemas, parseSchema, parseOperation, baseOas);
+		const { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan } = ensurePreScan(document, schemas, parseSchema, parseOperation, baseOas);
 		return createInputStream({
 			schemas,
 			parseSchema,