@kubb/adapter-oas 5.0.0-beta.91 → 5.0.0-beta.93

package/dist/index.d.ts

@@ -1138,10 +1138,6 @@ type SchemaObject$1 = {
    */
   enum?: Array<string | number | boolean | null>;
 } & (OpenAPIV3_1.SchemaObject | JSONSchema4 | JSONSchema6 | JSONSchema7);
-/**
- * HTTP method in the lowercase form an OpenAPI path item uses for its keys.
- */
-type HttpMethod = Lowercase<ast.HttpMethod>;
 /**
  * Normalized OpenAPI document after parsing.
  */
@@ -1308,5 +1304,5 @@ declare const adapterOasName = "oas";
  */
 declare const adapterOas: (options?: AdapterOasOptions | undefined) => import("@kubb/core").Adapter<AdapterOas>;
 //#endregion
-export { type AdapterOas, type AdapterOasOptions, type AdapterOasResolvedOptions, type ContentType, type DiscriminatorObject$1 as DiscriminatorObject, type Document, type HttpMethod, type MediaTypeObject$1 as MediaTypeObject, type Operation, type ReferenceObject$1 as ReferenceObject, type ResponseObject$1 as ResponseObject, type SchemaObject$1 as SchemaObject, adapterOas, adapterOasName };
+export { type AdapterOas, type AdapterOasOptions, type AdapterOasResolvedOptions, type ContentType, type DiscriminatorObject$1 as DiscriminatorObject, type Document, type MediaTypeObject$1 as MediaTypeObject, type Operation, type ReferenceObject$1 as ReferenceObject, type ResponseObject$1 as ResponseObject, type SchemaObject$1 as SchemaObject, adapterOas, adapterOasName };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -10,13 +10,6 @@ import { bundle } from "api-ref-bundler";
 //#region src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
-*
-* @example
-* ```ts
-* import { DEFAULT_PARSER_OPTIONS, parseOas } from '@kubb/adapter-oas'
-*
-* const { root } = parseOas(document, { ...DEFAULT_PARSER_OPTIONS, dateType: 'date' })
-* ```
 */
 const DEFAULT_PARSER_OPTIONS = {
 	dateType: "string",
@@ -55,14 +48,6 @@ const SUPPORTED_METHODS = /* @__PURE__ */ new Set([
 *
 * 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 = /* @__PURE__ */ new Set([
 	"properties",
@@ -92,15 +77,6 @@ const specialCasedFormats = /* @__PURE__ */ new Set([
 * 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'
-* ```
 */
 const formatMap = {
 	uuid: "uuid",
@@ -121,24 +97,10 @@ const formatMap = {
 };
 /**
 * 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"];
 /**
 * Vendor extension keys that attach human-readable descriptions to enum values, checked in priority order.
-*
-* @example
-* ```ts
-* import { enumDescriptionKeys } from '@kubb/adapter-oas'
-*
-* const key = enumDescriptionKeys.find((k) => k in schema) // 'x-enumDescriptions' | 'x-enum-descriptions' | undefined
-* ```
 */
 const enumDescriptionKeys = ["x-enumDescriptions", "x-enum-descriptions"];
 //#endregion
@@ -542,6 +504,18 @@ function isDiscriminator(obj) {
 	const record = obj;
 	return !!obj && !!record["discriminator"] && typeof record["discriminator"] !== "string";
 }
+/**
+* Returns `true` when a schema is a binary payload: an octet-stream string body.
+*
+* @example
+* ```ts
+* isBinary({ type: 'string', contentMediaType: 'application/octet-stream' }) // true
+* isBinary({ type: 'string' })                                               // false
+* ```
+*/
+function isBinary(schema) {
+	return schema.type === "string" && schema.contentMediaType === "application/octet-stream";
+}
 //#endregion
 //#region src/mime.ts
 /**
@@ -763,37 +737,6 @@ function getOperations(document) {
 	return operations;
 }
 //#endregion
-//#region src/dialect.ts
-/**
-* The OpenAPI / Swagger dialect, the default used by `@kubb/adapter-oas`.
-*
-* Implements the spec-agnostic {@link ast.SchemaDialect} contract: it isolates the
-* decisions that differ between specs (nullability, `$ref`, discriminator, binary,
-* ref resolution) so the converter pipeline and dispatch rules stay shared. A
-* future adapter (e.g. AsyncAPI) ships its own dialect, `type: ['null', …]`
-* nullability, no discriminator object, binary via `contentEncoding` and reuses
-* the rest unchanged.
-*
-* Formats (`uuid`, `email`, dates, …) are intentionally NOT here: they are shared
-* JSON Schema vocabulary, so the converters keep that common case.
-*
-* @example
-* ```ts
-* const parser = createSchemaParser(context)             // uses oasDialect
-* const parser = createSchemaParser(context, oasDialect) // explicit
-* ```
-*/
-const oasDialect = ast.defineDialect({
-	name: "oas",
-	schema: {
-		isNullable,
-		isReference,
-		isDiscriminator,
-		isBinary: (schema) => schema.type === "string" && schema.contentMediaType === "application/octet-stream",
-		resolveRef
-	}
-});
-//#endregion
 //#region src/resolvers.ts
 /**
 * Reads the server URL from the document's `servers` array at `server.index`,
@@ -901,19 +844,10 @@ function getResponseBody(responseBody, contentType) {
 		if (!(contentType in body.content)) return false;
 		return body.content[contentType];
 	}
-	let availableContentType;
 	const contentTypes = Object.keys(body.content);
-	for (const mt of contentTypes) if (isJsonMimeType(mt)) {
-		availableContentType = mt;
-		break;
-	}
-	if (!availableContentType) availableContentType = contentTypes[0];
-	if (availableContentType) return [
-		availableContentType,
-		body.content[availableContentType],
-		...body.description ? [body.description] : []
-	];
-	return false;
+	const availableContentType = contentTypes.find(isJsonMimeType) ?? contentTypes[0];
+	if (!availableContentType) return false;
+	return body.content[availableContentType];
 }
 /**
 * Returns the response schema for a given operation and HTTP status code.
@@ -942,7 +876,7 @@ function getResponseSchema(document, operation, statusCode, options = {}) {
 		statusCode
 	}), options.contentType);
 	if (responseBody === false) return {};
-	const schema = Array.isArray(responseBody) ? responseBody[1].schema : responseBody.schema;
+	const schema = responseBody.schema;
 	if (!schema) return {};
 	return dereferenceWithRef(document, schema);
 }
@@ -1313,7 +1247,7 @@ function nameEnums(node, options) {
 *
 * @internal
 */
-function createSchemaParser(ctx, dialect = oasDialect) {
+function createSchemaParser(ctx) {
 	const document = ctx.document;
 	/**
 	* Tracks `$ref` paths that are currently being resolved to prevent infinite
@@ -1339,7 +1273,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		if (!refExistence.has(refPath)) {
 			let exists = false;
 			try {
-				exists = !!dialect.schema.resolveRef(document, refPath);
+				exists = !!resolveRef(document, refPath);
 			} catch {
 				exists = false;
 			}
@@ -1361,7 +1295,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		if (refPath && !resolvingRefs.has(refPath)) {
 			if (!resolvedRefCache.has(refPath)) {
 				try {
-					const referenced = dialect.schema.resolveRef(document, refPath);
+					const referenced = resolveRef(document, refPath);
 					if (referenced) {
 						resolvingRefs.add(refPath);
 						resolvedSchema = parseSchema({ schema: referenced }, rawOptions);
@@ -1414,13 +1348,13 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		}
 		const filteredDiscriminantValues = [];
 		const allOfMembers = schema.allOf.filter((item) => {
-			if (!dialect.schema.isReference(item) || !name) return true;
-			const deref = dialect.schema.resolveRef(document, item.$ref);
-			if (!deref || !dialect.schema.isDiscriminator(deref)) return true;
+			if (!isReference(item) || !name) return true;
+			const deref = resolveRef(document, item.$ref);
+			if (!deref || !isDiscriminator(deref)) return true;
 			const parentUnion = deref.oneOf ?? deref.anyOf;
 			if (!parentUnion) return true;
 			const childRef = `${SCHEMA_REF_PREFIX}${name}`;
-			const inOneOf = parentUnion.some((oneOfItem) => dialect.schema.isReference(oneOfItem) && oneOfItem.$ref === childRef);
+			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 = findDiscriminator(deref.discriminator.mapping, childRef);
@@ -1441,9 +1375,9 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			const missingRequired = schema.required.filter((key) => !outerKeys.has(key));
 			if (missingRequired.length) {
 				const resolvedMembers = schema.allOf.flatMap((item) => {
-					if (!dialect.schema.isReference(item)) return [item];
-					const deref = dialect.schema.resolveRef(document, item.$ref);
-					return deref && !dialect.schema.isReference(deref) ? [deref] : [];
+					if (!isReference(item)) return [item];
+					const deref = resolveRef(document, item.$ref);
+					return deref && !isReference(deref) ? [deref] : [];
 				});
 				for (const key of missingRequired) for (const resolved of resolvedMembers) if (resolved.properties?.[key]) {
 					allOfMembers.push(parseSchema({
@@ -1489,7 +1423,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			return decodeURIComponent($ref.substring(1)).split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document) ?? null;
 		}
 		function implicitDiscriminantValue(member) {
-			if (!discriminator || discriminator.mapping || !dialect.schema.isReference(member)) return null;
+			if (!discriminator || discriminator.mapping || !isReference(member)) return null;
 			const value = extractRefName(member.$ref);
 			if (!value) return null;
 			const variant = resolveRefSilent(member.$ref);
@@ -1498,12 +1432,12 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			const seen = /* @__PURE__ */ new Set([member.$ref]);
 			function constrains(v) {
 				const prop = v.properties?.[propertyName];
-				const resolved = prop && dialect.schema.isReference(prop) ? resolveRefSilent(prop.$ref) : prop;
+				const resolved = prop && isReference(prop) ? resolveRefSilent(prop.$ref) : prop;
 				if (resolved && (Array.isArray(resolved.enum) || resolved.const !== void 0)) return true;
 				const composition = v.allOf ?? v.oneOf ?? v.anyOf;
 				if (!composition) return false;
 				return composition.some((m) => {
-					if (!dialect.schema.isReference(m)) return constrains(m);
+					if (!isReference(m)) return constrains(m);
 					if (seen.has(m.$ref)) return false;
 					seen.add(m.$ref);
 					const r = resolveRefSilent(m.$ref);
@@ -1516,10 +1450,10 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		const strategy = schema.oneOf ? "one" : "any";
 		const unionBase = {
 			...buildSchemaNode(schema, name, nullable, defaultValue),
-			discriminatorPropertyName: dialect.schema.isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
+			discriminatorPropertyName: isDiscriminator(schema) ? schema.discriminator.propertyName : void 0,
 			strategy
 		};
-		const discriminator = dialect.schema.isDiscriminator(schema) ? schema.discriminator : void 0;
+		const discriminator = isDiscriminator(schema) ? schema.discriminator : void 0;
 		const { oneOf: _o, anyOf: _a, discriminator: _d, ...memberBaseSchema } = schema;
 		const sharedPropertiesNode = schema.properties ? parseSchema({
 			schema: memberBaseSchema,
@@ -1527,7 +1461,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		}, rawOptions) : void 0;
 		if (sharedPropertiesNode || discriminator) {
 			const members = unionMembers.map((s) => {
-				const ref = dialect.schema.isReference(s) ? s.$ref : void 0;
+				const ref = isReference(s) ? s.$ref : void 0;
 				const discriminatorValue = findDiscriminator(discriminator?.mapping, ref) ?? implicitDiscriminantValue(s);
 				const memberNode = parseSchema({
 					schema: s,
@@ -1617,39 +1551,15 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		const specialType = getSchemaType(schema.format);
 		if (!specialType) return null;
 		const specialPrimitive = specialType === "number" || specialType === "integer" || specialType === "bigint" ? specialType : "string";
-		if (specialType === "number" || specialType === "integer" || specialType === "bigint") return ast.factory.createSchema({
-			...base,
-			primitive: specialPrimitive,
-			type: specialType
-		});
-		if (specialType === "url") return ast.factory.createSchema({
-			...base,
-			primitive: "string",
-			type: "url",
-			min: schema.minLength,
-			max: schema.maxLength
-		});
-		if (specialType === "ipv4") return ast.factory.createSchema({
-			...base,
-			primitive: "string",
-			type: "ipv4"
-		});
-		if (specialType === "ipv6") return ast.factory.createSchema({
-			...base,
-			primitive: "string",
-			type: "ipv6"
-		});
-		if (specialType === "uuid" || specialType === "email") return ast.factory.createSchema({
-			...base,
-			primitive: "string",
-			type: specialType,
-			min: schema.minLength,
-			max: schema.maxLength
-		});
+		const hasLength = specialType === "url" || specialType === "uuid" || specialType === "email";
 		return ast.factory.createSchema({
 			...base,
 			primitive: specialPrimitive,
-			type: specialType
+			type: specialType,
+			...hasLength ? {
+				min: schema.minLength,
+				max: schema.maxLength
+			} : {}
 		});
 	}
 	/**
@@ -1669,16 +1579,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		const enumBase = {
 			type: "enum",
 			primitive: enumPrimitive,
-			name,
-			title: schema.title,
-			description: schema.description,
-			deprecated: schema.deprecated,
-			nullable: enumNullable,
-			readOnly: schema.readOnly,
-			writeOnly: schema.writeOnly,
-			default: enumDefault,
-			examples: extractExamples(schema),
-			format: schema.format
+			...buildSchemaNode(schema, name, enumNullable, enumDefault)
 		};
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
 		const descriptionKey = enumDescriptionKeys.find((key) => key in schema);
@@ -1715,7 +1616,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		const properties = schema.properties ? Object.entries(schema.properties).map(([propName, propSchema]) => {
 			const required = Array.isArray(schema.required) ? schema.required.includes(propName) : !!schema.required;
 			const resolvedPropSchema = propSchema;
-			const propNullable = dialect.schema.isNullable(resolvedPropSchema);
+			const propNullable = isNullable(resolvedPropSchema);
 			const schemaNode = nameEnums(parseSchema({
 				schema: resolvedPropSchema,
 				name: childName(name, propName)
@@ -1752,7 +1653,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			maxProperties: schema.maxProperties,
 			...buildSchemaNode(schema, name, nullable, defaultValue)
 		});
-		if (dialect.schema.isDiscriminator(schema) && schema.discriminator.mapping) {
+		if (isDiscriminator(schema) && schema.discriminator.mapping) {
 			const discPropName = schema.discriminator.propertyName;
 			const values = Object.keys(schema.discriminator.mapping);
 			const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : void 0;
@@ -1880,7 +1781,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 	*/
 	const schemaRules = [
 		{
-			match: ({ schema }) => dialect.schema.isReference(schema),
+			match: ({ schema }) => isReference(schema),
 			convert: convertRef
 		},
 		{
@@ -1900,7 +1801,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			convert: convertFormat
 		},
 		{
-			match: ({ schema }) => dialect.schema.isBinary(schema),
+			match: ({ schema }) => isBinary(schema),
 			convert: convertBlob
 		},
 		{
@@ -1969,7 +1870,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			schema: flattenedSchema,
 			name
 		}, rawOptions);
-		const nullable = dialect.schema.isNullable(schema) || void 0;
+		const nullable = isNullable(schema) || void 0;
 		const schemaCtx = {
 			schema,
 			name,
@@ -2039,7 +1940,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 		const keys = [];
 		for (const key in schema.properties) {
 			const prop = schema.properties[key];
-			if (prop && !dialect.schema.isReference(prop) && prop[flag]) keys.push(key);
+			if (prop && !isReference(prop) && prop[flag]) keys.push(key);
 		}
 		return keys.length ? keys : null;
 	}
@@ -2106,7 +2007,7 @@ function createSchemaParser(ctx, dialect = oasDialect) {
 			});
 		});
 		const pathItem = document.paths?.[operation.path];
-		const pathItemDoc = pathItem && !dialect.schema.isReference(pathItem) ? pathItem : void 0;
+		const pathItemDoc = pathItem && !isReference(pathItem) ? pathItem : void 0;
 		const pickDoc = (key) => {
 			const own = operation.schema[key];
 			if (typeof own === "string") return own;
@@ -2298,13 +2199,10 @@ const adapterOas = createAdapter((options) => {
 	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;
+		const result = getSchemas(document, { contentType });
+		nameMapping = result.nameMapping;
+		schemasCache.set(document, result.schemas);
+		return result.schemas;
 	}
 	function ensureSchemaParser(document) {
 		const cached = schemaParserCache.get(document);
@@ -2420,7 +2318,7 @@ const adapterOas = createAdapter((options) => {
 			const document = await ensureDocument(source);
 			return parseInput({
 				document,
-				schemas: await ensureSchemas(document),
+				schemas: ensureSchemas(document),
 				parser: ensureSchemaParser(document)
 			});
 		}