@kubb/adapter-oas 5.0.0-alpha.38 → 5.0.0-alpha.39

package/dist/index.d.ts

@@ -1,7 +1,10 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
 import * as _$_kubb_core0 from "@kubb/core";
-import { AdapterFactoryOptions, ast } from "@kubb/core";
-import { OASDocument } from "oas/types";
+import { AdapterFactoryOptions, AdapterSource, ast } from "@kubb/core";
+import { DiscriminatorObject as DiscriminatorObject$1, MediaTypeObject as MediaTypeObject$1, OASDocument, ResponseObject as ResponseObject$1, SchemaObject as SchemaObject$1 } from "oas/types";
+import { Operation as Operation$1 } from "oas/operation";
+import { OpenAPIV3 } from "openapi-types";
+
 //#region src/types.d.ts
 /**
  * Content-type string used when selecting request/response schemas from a spec.
@@ -14,10 +17,87 @@ import { OASDocument } from "oas/types";
  * ```
  */
 type ContentType = 'application/json' | (string & {});
+/**
+ * Augments `oas`'s `SchemaObject` with OAS 3.1 / JSON Schema fields the parser needs.
+ *
+ * @example
+ * ```ts
+ * const schema: SchemaObject = {
+ *   type: 'string',
+ *   const: 'dog',
+ *   contentMediaType: 'application/octet-stream',
+ * }
+ * ```
+ */
+type SchemaObject = SchemaObject$1 & {
+  /**
+   * OAS 3.0 vendor extension: marks a schema as nullable without using `type: ['null', ...]`.
+   */
+  'x-nullable'?: boolean;
+  /**
+   * OAS 3.1: constrains the schema to a single fixed value (equivalent to a one-item `enum`).
+   */
+  const?: string | number | boolean | null;
+  /**
+   * OAS 3.1: media type of the schema content. `'application/octet-stream'` on a `string` schema maps to `blob`.
+   */
+  contentMediaType?: string;
+  $ref?: string;
+  /**
+   * OAS 3.1: positional tuple items, replacing the multi-item `items` array from OAS 3.0.
+   */
+  prefixItems?: Array<SchemaObject | ReferenceObject>;
+  /**
+   * JSON Schema: maps regex patterns to sub-schemas for validating additional properties.
+   */
+  patternProperties?: Record<string, SchemaObject | boolean>;
+  /**
+   * Single-schema form of `items`. Narrowed from the base type to take precedence over the tuple overload.
+   */
+  items?: SchemaObject | ReferenceObject;
+  /**
+   * Enum values for this schema (narrowed from `unknown[]`).
+   */
+  enum?: Array<string | number | boolean | null>;
+};
+/**
+ * Uppercase → lowercase HTTP method map, re-exported for backwards compatibility.
+ *
+ * @example
+ * ```ts
+ * HttpMethods['GET'] // 'get'
+ * HttpMethods['POST'] // 'post'
+ * ```
+ */
+declare const HttpMethods: Record<Uppercase<ast.HttpMethod>, Lowercase<ast.HttpMethod>>;
+/**
+ * Lowercase HTTP method string as used by the `oas` package (`'get' | 'post' | ...`).
+ */
+type HttpMethod = Lowercase<ast.HttpMethod>;
 /**
  * Normalized OpenAPI document type used throughout the adapter.
  */
 type Document = OASDocument;
+/**
+ * Operation wrapper type returned by the `oas` package.
+ */
+type Operation = Operation$1;
+/**
+ * OpenAPI `discriminator` object attached to a `oneOf`/`anyOf` schema.
+ */
+type DiscriminatorObject = DiscriminatorObject$1;
+/**
+ * OpenAPI `$ref` pointer object (`{ $ref: string }`).
+ */
+type ReferenceObject = OpenAPIV3.ReferenceObject;
+/**
+ * OpenAPI response object type (may contain `content`, `description`, `headers`).
+ */
+type ResponseObject = ResponseObject$1;
+/**
+ * OpenAPI media type object that maps a content-type to a schema.
+ */
+type MediaTypeObject = MediaTypeObject$1;
 /**
  * User-facing options for `adapterOas(...)`.
  *
@@ -127,5 +207,69 @@ declare const adapterOasName = "oas";
  */
 declare const adapterOas: (options?: AdapterOasOptions | undefined) => _$_kubb_core0.Adapter<AdapterOas>;
 //#endregion
-export { type AdapterOas, adapterOas, adapterOasName };
+//#region src/factory.d.ts
+type ParseOptions = {
+  canBundle?: boolean;
+  enablePaths?: boolean;
+};
+type ValidateDocumentOptions = {
+  throwOnError?: boolean;
+};
+/**
+ * Loads and dereferences an OpenAPI document, returning the raw `Document`.
+ *
+ * Accepts a file path string or an already-parsed document object. File paths are bundled via
+ * Redocly to resolve external `$ref`s. Swagger 2.0 documents are automatically up-converted
+ * to OpenAPI 3.0 via `swagger2openapi`.
+ *
+ * @example
+ * ```ts
+ * const document = await parseDocument('./openapi.yaml')
+ * const document = await parse(rawDocumentObject, { canBundle: false })
+ * ```
+ */
+declare function parseDocument(pathOrApi: string | Document, {
+  canBundle,
+  enablePaths
+}?: ParseOptions): Promise<Document>;
+/**
+ * Deep-merges multiple OpenAPI documents into a single `Document`.
+ *
+ * Each document is parsed independently then recursively merged with `remeda`'s `mergeDeep`.
+ * Throws when the input array is empty.
+ *
+ * @example
+ * ```ts
+ * const document = await mergeDocuments(['./pets.yaml', './orders.yaml'])
+ * ```
+ */
+declare function mergeDocuments(pathOrApi: Array<string | Document>): Promise<Document>;
+/**
+ * Creates a `Document` from an `AdapterSource`.
+ *
+ * Handles all three source types:
+ * - `{ type: 'path' }` — resolves and bundles a local file path or remote URL.
+ * - `{ type: 'paths' }` — merges multiple file paths into a single document.
+ * - `{ type: 'data' }` — parses an inline string (YAML/JSON) or raw object.
+ *
+ * @example
+ * ```ts
+ * const document = await parseFromConfig({ type: 'path', path: './openapi.yaml' })
+ * const document = await parseFromConfig({ type: 'data', data: '{"openapi":"3.0.0",...}' })
+ * ```
+ */
+declare function parseFromConfig(source: AdapterSource): Promise<Document>;
+/**
+ * Validates an OpenAPI document using `oas-normalize` with colorized error output.
+ *
+ * @example
+ * ```ts
+ * await validateDocument(document)
+ * ```
+ */
+declare function validateDocument(document: Document, {
+  throwOnError
+}?: ValidateDocumentOptions): Promise<void>;
+//#endregion
+export { type AdapterOas, type AdapterOasOptions, type AdapterOasResolvedOptions, type ContentType, type DiscriminatorObject, type Document, type HttpMethod, HttpMethods, type MediaTypeObject, type Operation, type ParseOptions, type ReferenceObject, type ResponseObject, type SchemaObject, type ValidateDocumentOptions, adapterOas, adapterOasName, mergeDocuments, parseDocument, parseFromConfig, validateDocument };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -581,13 +581,15 @@ function parseFromConfig(source) {
 * await validateDocument(document)
 * ```
 */
-async function validateDocument(document) {
+async function validateDocument(document, { throwOnError = false } = {}) {
 	try {
 		await new OASNormalize(document, {
 			enablePaths: true,
 			colorizeErrors: true
 		}).validate({ parser: { validate: { errors: { colorize: true } } } });
-	} catch (_err) {}
+	} catch (error) {
+		if (throwOnError) throw error;
+	}
 }
 //#endregion
 //#region src/refs.ts
@@ -1745,6 +1747,18 @@ const adapterOas = createAdapter((options) => {
 	};
 });
 //#endregion
-export { adapterOas, adapterOasName };
+//#region src/types.ts
+/**
+* Uppercase → lowercase HTTP method map, re-exported for backwards compatibility.
+*
+* @example
+* ```ts
+* HttpMethods['GET'] // 'get'
+* HttpMethods['POST'] // 'post'
+* ```
+*/
+const HttpMethods = Object.fromEntries(Object.entries(ast.httpMethods).map(([lower, upper]) => [upper, lower]));
+//#endregion
+export { HttpMethods, adapterOas, adapterOasName, mergeDocuments, parseDocument, parseFromConfig, validateDocument };
 
 //# sourceMappingURL=index.js.map