@kubb/adapter-oas 5.0.0-alpha.41 → 5.0.0-alpha.43

package/dist/index.d.ts

@@ -1,10 +1,329 @@
 import { t as __name } from "./chunk--u3MIqq1.js";
 import * as _$_kubb_core0 from "@kubb/core";
 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 { 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";
-import { OpenAPIV3 } from "openapi-types";
 
+//#region ../../node_modules/.pnpm/openapi-types@12.1.3/node_modules/openapi-types/dist/index.d.ts
+declare namespace OpenAPIV3 {
+  interface Document<T extends {} = {}> {
+    openapi: string;
+    info: InfoObject;
+    servers?: ServerObject[];
+    paths: PathsObject<T>;
+    components?: ComponentsObject;
+    security?: SecurityRequirementObject[];
+    tags?: TagObject[];
+    externalDocs?: ExternalDocumentationObject;
+    'x-express-openapi-additional-middleware'?: (((request: any, response: any, next: any) => Promise<void>) | ((request: any, response: any, next: any) => void))[];
+    'x-express-openapi-validation-strict'?: boolean;
+  }
+  interface InfoObject {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: ContactObject;
+    license?: LicenseObject;
+    version: string;
+  }
+  interface ContactObject {
+    name?: string;
+    url?: string;
+    email?: string;
+  }
+  interface LicenseObject {
+    name: string;
+    url?: string;
+  }
+  interface ServerObject {
+    url: string;
+    description?: string;
+    variables?: {
+      [variable: string]: ServerVariableObject;
+    };
+  }
+  interface ServerVariableObject {
+    enum?: string[];
+    default: string;
+    description?: string;
+  }
+  interface PathsObject<T extends {} = {}, P extends {} = {}> {
+    [pattern: string]: (PathItemObject<T> & P) | undefined;
+  }
+  enum HttpMethods {
+    GET = "get",
+    PUT = "put",
+    POST = "post",
+    DELETE = "delete",
+    OPTIONS = "options",
+    HEAD = "head",
+    PATCH = "patch",
+    TRACE = "trace"
+  }
+  type PathItemObject<T extends {} = {}> = {
+    $ref?: string;
+    summary?: string;
+    description?: string;
+    servers?: ServerObject[];
+    parameters?: (ReferenceObject | ParameterObject)[];
+  } & { [method in HttpMethods]?: OperationObject<T> };
+  type OperationObject<T extends {} = {}> = {
+    tags?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+    operationId?: string;
+    parameters?: (ReferenceObject | ParameterObject)[];
+    requestBody?: ReferenceObject | RequestBodyObject;
+    responses: ResponsesObject;
+    callbacks?: {
+      [callback: string]: ReferenceObject | CallbackObject;
+    };
+    deprecated?: boolean;
+    security?: SecurityRequirementObject[];
+    servers?: ServerObject[];
+  } & T;
+  interface ExternalDocumentationObject {
+    description?: string;
+    url: string;
+  }
+  interface ParameterObject extends ParameterBaseObject {
+    name: string;
+    in: string;
+  }
+  interface HeaderObject extends ParameterBaseObject {}
+  interface ParameterBaseObject {
+    description?: string;
+    required?: boolean;
+    deprecated?: boolean;
+    allowEmptyValue?: boolean;
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+  }
+  type NonArraySchemaObjectType = 'boolean' | 'object' | 'number' | 'string' | 'integer';
+  type ArraySchemaObjectType = 'array';
+  type SchemaObject = ArraySchemaObject | NonArraySchemaObject;
+  interface ArraySchemaObject extends BaseSchemaObject {
+    type: ArraySchemaObjectType;
+    items: ReferenceObject | SchemaObject;
+  }
+  interface NonArraySchemaObject extends BaseSchemaObject {
+    type?: NonArraySchemaObjectType;
+  }
+  interface BaseSchemaObject {
+    title?: string;
+    description?: string;
+    format?: string;
+    default?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    additionalProperties?: boolean | ReferenceObject | SchemaObject;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    enum?: any[];
+    properties?: {
+      [name: string]: ReferenceObject | SchemaObject;
+    };
+    allOf?: (ReferenceObject | SchemaObject)[];
+    oneOf?: (ReferenceObject | SchemaObject)[];
+    anyOf?: (ReferenceObject | SchemaObject)[];
+    not?: ReferenceObject | SchemaObject;
+    nullable?: boolean;
+    discriminator?: DiscriminatorObject;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    xml?: XMLObject;
+    externalDocs?: ExternalDocumentationObject;
+    example?: any;
+    deprecated?: boolean;
+  }
+  interface DiscriminatorObject {
+    propertyName: string;
+    mapping?: {
+      [value: string]: string;
+    };
+  }
+  interface XMLObject {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: boolean;
+    wrapped?: boolean;
+  }
+  interface ReferenceObject {
+    $ref: string;
+  }
+  interface ExampleObject {
+    summary?: string;
+    description?: string;
+    value?: any;
+    externalValue?: string;
+  }
+  interface MediaTypeObject {
+    schema?: ReferenceObject | SchemaObject;
+    example?: any;
+    examples?: {
+      [media: string]: ReferenceObject | ExampleObject;
+    };
+    encoding?: {
+      [media: string]: EncodingObject;
+    };
+  }
+  interface EncodingObject {
+    contentType?: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    style?: string;
+    explode?: boolean;
+    allowReserved?: boolean;
+  }
+  interface RequestBodyObject {
+    description?: string;
+    content: {
+      [media: string]: MediaTypeObject;
+    };
+    required?: boolean;
+  }
+  interface ResponsesObject {
+    [code: string]: ReferenceObject | ResponseObject;
+  }
+  interface ResponseObject {
+    description: string;
+    headers?: {
+      [header: string]: ReferenceObject | HeaderObject;
+    };
+    content?: {
+      [media: string]: MediaTypeObject;
+    };
+    links?: {
+      [link: string]: ReferenceObject | LinkObject;
+    };
+  }
+  interface LinkObject {
+    operationRef?: string;
+    operationId?: string;
+    parameters?: {
+      [parameter: string]: any;
+    };
+    requestBody?: any;
+    description?: string;
+    server?: ServerObject;
+  }
+  interface CallbackObject {
+    [url: string]: PathItemObject;
+  }
+  interface SecurityRequirementObject {
+    [name: string]: string[];
+  }
+  interface ComponentsObject {
+    schemas?: {
+      [key: string]: ReferenceObject | SchemaObject;
+    };
+    responses?: {
+      [key: string]: ReferenceObject | ResponseObject;
+    };
+    parameters?: {
+      [key: string]: ReferenceObject | ParameterObject;
+    };
+    examples?: {
+      [key: string]: ReferenceObject | ExampleObject;
+    };
+    requestBodies?: {
+      [key: string]: ReferenceObject | RequestBodyObject;
+    };
+    headers?: {
+      [key: string]: ReferenceObject | HeaderObject;
+    };
+    securitySchemes?: {
+      [key: string]: ReferenceObject | SecuritySchemeObject;
+    };
+    links?: {
+      [key: string]: ReferenceObject | LinkObject;
+    };
+    callbacks?: {
+      [key: string]: ReferenceObject | CallbackObject;
+    };
+  }
+  type SecuritySchemeObject = HttpSecurityScheme | ApiKeySecurityScheme | OAuth2SecurityScheme | OpenIdSecurityScheme;
+  interface HttpSecurityScheme {
+    type: 'http';
+    description?: string;
+    scheme: string;
+    bearerFormat?: string;
+  }
+  interface ApiKeySecurityScheme {
+    type: 'apiKey';
+    description?: string;
+    name: string;
+    in: string;
+  }
+  interface OAuth2SecurityScheme {
+    type: 'oauth2';
+    description?: string;
+    flows: {
+      implicit?: {
+        authorizationUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      password?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      clientCredentials?: {
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+      authorizationCode?: {
+        authorizationUrl: string;
+        tokenUrl: string;
+        refreshUrl?: string;
+        scopes: {
+          [scope: string]: string;
+        };
+      };
+    };
+  }
+  interface OpenIdSecurityScheme {
+    type: 'openIdConnect';
+    description?: string;
+    openIdConnectUrl: string;
+  }
+  interface TagObject {
+    name: string;
+    description?: string;
+    externalDocs?: ExternalDocumentationObject;
+  }
+}
+//#endregion
 //#region src/types.d.ts
 /**
  * Content-type string used when selecting request/response schemas from a spec.
@@ -29,7 +348,7 @@ type ContentType = 'application/json' | (string & {});
  * }
  * ```
  */
-type SchemaObject = SchemaObject$1 & {
+type SchemaObject$1 = SchemaObject$2 & {
   /**
    * OAS 3.0 vendor extension: marks a schema as nullable without using `type: ['null', ...]`.
    */
@@ -46,15 +365,15 @@ type SchemaObject = SchemaObject$1 & {
   /**
    * OAS 3.1: positional tuple items, replacing the multi-item `items` array from OAS 3.0.
    */
-  prefixItems?: Array<SchemaObject | ReferenceObject>;
+  prefixItems?: Array<SchemaObject$1 | ReferenceObject$1>;
   /**
    * JSON Schema: maps regex patterns to sub-schemas for validating additional properties.
    */
-  patternProperties?: Record<string, SchemaObject | boolean>;
+  patternProperties?: Record<string, SchemaObject$1 | boolean>;
   /**
    * Single-schema form of `items`. Narrowed from the base type to take precedence over the tuple overload.
    */
-  items?: SchemaObject | ReferenceObject;
+  items?: SchemaObject$1 | ReferenceObject$1;
   /**
    * Enum values for this schema (narrowed from `unknown[]`).
    */
@@ -69,7 +388,7 @@ type SchemaObject = SchemaObject$1 & {
  * HttpMethods['POST'] // 'post'
  * ```
  */
-declare const HttpMethods: Record<Uppercase<ast.HttpMethod>, Lowercase<ast.HttpMethod>>;
+declare const HttpMethods$1: Record<Uppercase<ast.HttpMethod>, Lowercase<ast.HttpMethod>>;
 /**
  * Lowercase HTTP method string as used by the `oas` package (`'get' | 'post' | ...`).
  */
@@ -85,19 +404,19 @@ type Operation = Operation$1;
 /**
  * OpenAPI `discriminator` object attached to a `oneOf`/`anyOf` schema.
  */
-type DiscriminatorObject = DiscriminatorObject$1;
+type DiscriminatorObject$1 = DiscriminatorObject$2;
 /**
  * OpenAPI `$ref` pointer object (`{ $ref: string }`).
  */
-type ReferenceObject = OpenAPIV3.ReferenceObject;
+type ReferenceObject$1 = OpenAPIV3.ReferenceObject;
 /**
  * OpenAPI response object type (may contain `content`, `description`, `headers`).
  */
-type ResponseObject = ResponseObject$1;
+type ResponseObject$1 = ResponseObject$2;
 /**
  * OpenAPI media type object that maps a content-type to a schema.
  */
-type MediaTypeObject = MediaTypeObject$1;
+type MediaTypeObject$1 = MediaTypeObject$2;
 /**
  * User-facing options for `adapterOas(...)`.
  *
@@ -194,7 +513,7 @@ declare const adapterOasName = "oas";
  *
  * @example
  * ```ts
- * import { defineConfig } from '@kubb/core'
+ * import { defineConfig } from 'kubb'
  * import { adapterOas } from '@kubb/adapter-oas'
  * import { pluginTs } from '@kubb/plugin-ts'
  *
@@ -235,7 +554,7 @@ declare function parseDocument(pathOrApi: string | Document, {
 /**
  * Deep-merges multiple OpenAPI documents into a single `Document`.
  *
- * Each document is parsed independently then recursively merged with `remeda`'s `mergeDeep`.
+ * Each document is parsed independently then recursively merged via `mergeDeep` from `@internals/utils`.
  * Throws when the input array is empty.
  *
  * @example
@@ -271,5 +590,5 @@ 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 };
+export { type AdapterOas, type AdapterOasOptions, type AdapterOasResolvedOptions, type ContentType, type DiscriminatorObject$1 as DiscriminatorObject, type Document, type HttpMethod, HttpMethods$1 as HttpMethods, type MediaTypeObject$1 as MediaTypeObject, type Operation, type ParseOptions, type ReferenceObject$1 as ReferenceObject, type ResponseObject$1 as ResponseObject, type SchemaObject$1 as SchemaObject, type ValidateDocumentOptions, adapterOas, adapterOasName, mergeDocuments, parseDocument, parseFromConfig, validateDocument };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,12 +2,9 @@ import "./chunk--u3MIqq1.js";
 import { ast, createAdapter } from "@kubb/core";
 import path from "node:path";
 import { bundle, loadConfig } from "@redocly/openapi-core";
-import yaml from "@stoplight/yaml";
 import OASNormalize from "oas-normalize";
-import { isPlainObject, mergeDeep } from "remeda";
 import swagger2openapi from "swagger2openapi";
 import BaseOas from "oas";
-import jsonpointer from "jsonpointer";
 import { isRef } from "oas/types";
 import { matchesMimeType } from "oas/utils";
 //#region src/constants.ts
@@ -258,6 +255,40 @@ function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
 }
 //#endregion
+//#region ../../internals/utils/src/object.ts
+/**
+* Returns `true` when `value` is a plain (non-null, non-array) object.
+*
+* @example
+* ```ts
+* isPlainObject({})          // true
+* isPlainObject([])          // false
+* isPlainObject(null)        // false
+* ```
+*/
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && Object.getPrototypeOf(value) === Object.prototype;
+}
+/**
+* Recursively merges `source` into `target`, combining nested plain objects.
+* Arrays and non-object values from `source` override the corresponding values in `target`.
+*
+* @example
+* ```ts
+* mergeDeep({ a: { x: 1 } }, { a: { y: 2 } })
+* // { a: { x: 1, y: 2 } }
+* ```
+*/
+function mergeDeep(target, source) {
+	const result = { ...target };
+	for (const key of Object.keys(source)) {
+		const sv = source[key];
+		const tv = result[key];
+		result[key] = sv !== null && typeof sv === "object" && !Array.isArray(sv) && tv !== null && typeof tv === "object" && !Array.isArray(tv) ? mergeDeep(tv, sv) : sv;
+	}
+	return result;
+}
+//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * Returns `true` when `name` is a syntactically valid JavaScript variable name.
@@ -520,7 +551,7 @@ async function parseDocument(pathOrApi, { canBundle = true, enablePaths = true }
 /**
 * Deep-merges multiple OpenAPI documents into a single `Document`.
 *
-* Each document is parsed independently then recursively merged with `remeda`'s `mergeDeep`.
+* Each document is parsed independently then recursively merged via `mergeDeep` from `@internals/utils`.
 * Throws when the input array is empty.
 *
 * @example
@@ -563,11 +594,7 @@ async function mergeDocuments(pathOrApi) {
 function parseFromConfig(source) {
 	if (source.type === "data") {
 		if (typeof source.data === "object") return parseDocument(structuredClone(source.data));
-		try {
-			return parseDocument(yaml.parse(source.data));
-		} catch {
-			return parseDocument(source.data);
-		}
+		return parseDocument(source.data, { canBundle: false });
 	}
 	if (source.type === "paths") return mergeDocuments(source.paths);
 	if (new URLPath(source.path).isURL) return parseDocument(source.path);
@@ -610,7 +637,7 @@ function resolveRef(document, $ref) {
 	if ($ref === "") return null;
 	if ($ref.startsWith("#")) $ref = globalThis.decodeURIComponent($ref.substring(1));
 	else return null;
-	const current = jsonpointer.get(document, $ref);
+	const current = $ref.split("/").filter(Boolean).reduce((obj, key) => obj?.[key], document);
 	if (!current) throw new Error(`Could not find a definition for ${origRef}.`);
 	return current;
 }
@@ -1295,15 +1322,21 @@ function createSchemaParser(ctx) {
 		const extensionKey = enumExtensionKeys.find((key) => key in schema);
 		if (extensionKey || enumPrimitive === "number" || enumPrimitive === "integer" || enumPrimitive === "boolean") {
 			const enumPrimitiveType = enumPrimitive === "number" || enumPrimitive === "integer" ? "number" : enumPrimitive === "boolean" ? "boolean" : "string";
-			const sourceValues = extensionKey ? [...new Set(schema[extensionKey])] : [...new Set(filteredValues)];
+			const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
+			const uniqueValues = [...new Set(filteredValues)];
+			const seenNames = /* @__PURE__ */ new Set();
 			return ast.createSchema({
 				...enumBase,
 				primitive: enumPrimitiveType,
-				namedEnumValues: sourceValues.map((label, index) => ({
-					name: String(label),
-					value: extensionKey ? filteredValues[index] ?? label : label,
+				namedEnumValues: uniqueValues.map((value, index) => ({
+					name: String(rawEnumNames?.[index] ?? value),
+					value,
 					primitive: enumPrimitiveType
-				}))
+				})).filter((entry) => {
+					if (seenNames.has(entry.name)) return false;
+					seenNames.add(entry.name);
+					return true;
+				})
 			});
 		}
 		return ast.createSchema({
@@ -1664,7 +1697,7 @@ const adapterOasName = "oas";
 *
 * @example
 * ```ts
-* import { defineConfig } from '@kubb/core'
+* import { defineConfig } from 'kubb'
 * import { adapterOas } from '@kubb/adapter-oas'
 * import { pluginTs } from '@kubb/plugin-ts'
 *