@kubb/oas 4.12.10 → 4.12.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/oas",
-  "version": "4.12.10",
+  "version": "4.12.11",
   "description": "OpenAPI Specification (OAS) utilities and helpers for Kubb, providing parsing, normalization, and manipulation of OpenAPI/Swagger schemas.",
   "keywords": [
     "openapi",
@@ -26,21 +26,13 @@
       "require": "./dist/index.cjs",
       "import": "./dist/index.js"
     },
-    "./infer": {
-      "require": "./dist/infer.cjs",
-      "import": "./dist/infer.js"
-    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.cts",
   "typesVersions": {
-    "*": {
-      "infer": [
-        "./dist/infer.d.ts"
-      ]
-    }
+    "*": {}
   },
   "files": [
     "src",
@@ -57,7 +49,6 @@
   ],
   "dependencies": {
     "@redocly/openapi-core": "^2.14.0",
-    "hotscript": "^1.0.13",
     "json-schema-to-ts": "^3.1.1",
     "jsonpointer": "^5.0.1",
     "oas": "^28.7.0",
@@ -65,8 +56,7 @@
     "openapi-types": "^12.1.3",
     "remeda": "^2.32.0",
     "swagger2openapi": "^7.0.8",
-    "ts-toolbelt": "^9.6.0",
-    "@kubb/core": "4.12.10"
+    "@kubb/core": "4.12.11"
   },
   "devDependencies": {
     "@stoplight/yaml": "^4.3.0",

package/src/Oas.ts

@@ -1,12 +1,8 @@
 import jsonpointer from 'jsonpointer'
 import BaseOas from 'oas'
-import type { Operation } from 'oas/operation'
-import type { MediaTypeObject, OASDocument, ResponseObject, SchemaObject, User } from 'oas/types'
+
 import { matchesMimeType } from 'oas/utils'
-import OASNormalize from 'oas-normalize'
-import type { OpenAPIV3 } from 'openapi-types'
-import type { OasTypes } from './index.ts'
-import type { contentType } from './types.ts'
+import type { contentType, DiscriminatorObject, Document, MediaTypeObject, Operation, ReferenceObject, ResponseObject, SchemaObject } from './types.ts'
 import { isDiscriminator, isReference, STRUCTURAL_KEYS } from './utils.ts'
 
 type Options = {
@@ -14,20 +10,16 @@ type Options = {
   discriminator?: 'strict' | 'inherit'
 }
 
-export class Oas<const TOAS = unknown> extends BaseOas {
+export class Oas extends BaseOas {
   #options: Options = {
     discriminator: 'strict',
   }
-  document: TOAS = undefined as unknown as TOAS
-
-  constructor({ oas, user }: { oas: TOAS | OASDocument | string; user?: User }) {
-    if (typeof oas === 'string') {
-      oas = JSON.parse(oas)
-    }
+  document: Document
 
-    super(oas as OASDocument, user)
+  constructor(document: Document) {
+    super(document, undefined)
 
-    this.document = oas as TOAS
+    this.document = document
   }
 
   setOptions(options: Options) {
@@ -45,11 +37,11 @@ export class Oas<const TOAS = unknown> extends BaseOas {
     return this.#options
   }
 
-  get($ref: string) {
+  get<T = unknown>($ref: string): T | null {
     const origRef = $ref
     $ref = $ref.trim()
     if ($ref === '') {
-      return false
+      return null
     }
     if ($ref.startsWith('#')) {
       $ref = globalThis.decodeURIComponent($ref.substring(1))
@@ -80,13 +72,17 @@ export class Oas<const TOAS = unknown> extends BaseOas {
     }
   }
 
-  #setDiscriminator(schema: OasTypes.SchemaObject & { discriminator: OpenAPIV3.DiscriminatorObject }): void {
+  #setDiscriminator(schema: SchemaObject & { discriminator: DiscriminatorObject }): void {
     const { mapping = {}, propertyName } = schema.discriminator
 
     if (this.#options.discriminator === 'inherit') {
       Object.entries(mapping).forEach(([mappingKey, mappingValue]) => {
         if (mappingValue) {
-          const childSchema = this.get(mappingValue)
+          const childSchema = this.get<any>(mappingValue)
+          if (!childSchema) {
+            return
+          }
+
           if (!childSchema.properties) {
             childSchema.properties = {}
           }
@@ -95,11 +91,12 @@ export class Oas<const TOAS = unknown> extends BaseOas {
 
           if (childSchema.properties) {
             childSchema.properties[propertyName] = {
-              ...(childSchema.properties ? childSchema.properties[propertyName] : {}),
+              ...((childSchema.properties ? childSchema.properties[propertyName] : {}) as SchemaObject),
               enum: [...(property?.enum?.filter((value) => value !== mappingKey) ?? []), mappingKey],
             }
 
-            childSchema.required = [...new Set([...(childSchema.required ?? []), propertyName])]
+            childSchema.required =
+              typeof childSchema.required === 'boolean' ? childSchema.required : [...new Set([...(childSchema.required ?? []), propertyName])]
 
             this.set(mappingValue, childSchema)
           }
@@ -108,50 +105,100 @@ export class Oas<const TOAS = unknown> extends BaseOas {
     }
   }
 
-  getDiscriminator(schema: OasTypes.SchemaObject): OpenAPIV3.DiscriminatorObject | undefined {
-    if (!isDiscriminator(schema)) {
-      return undefined
+  getDiscriminator(schema: SchemaObject | null): DiscriminatorObject | null {
+    if (!isDiscriminator(schema) || !schema) {
+      return null
     }
 
     const { mapping = {}, propertyName } = schema.discriminator
 
-    // loop over oneOf and add default mapping when none is defined
-    if (schema.oneOf) {
-      schema.oneOf.forEach((schema) => {
-        if (isReference(schema)) {
-          const key = this.getKey(schema.$ref)
-          const refSchema: OpenAPIV3.SchemaObject = this.get(schema.$ref)
-          // special case where enum in the schema is set without mapping being defined, see https://github.com/kubb-labs/kubb/issues/1669
-          const propertySchema = refSchema.properties?.[propertyName] as OpenAPIV3.SchemaObject
-          const canAdd = key && !Object.values(mapping).includes(schema.$ref)
-
-          if (canAdd && propertySchema?.enum?.length === 1) {
-            mapping[propertySchema.enum[0]] = schema.$ref
-          } else if (canAdd) {
-            mapping[key] = schema.$ref
-          }
+    /**
+     * Helper to extract discriminator value from a schema.
+     * Checks in order:
+     * 1. Extension property matching propertyName (e.g., x-linode-ref-name)
+     * 2. Property with const value
+     * 3. Property with single enum value
+     * 4. Title as fallback
+     */
+    const getDiscriminatorValue = (schema: SchemaObject | null): string | null => {
+      if (!schema) {
+        return null
+      }
+
+      // Check extension properties first (e.g., x-linode-ref-name)
+      // Only check if propertyName starts with 'x-' to avoid conflicts with standard properties
+      if (propertyName.startsWith('x-')) {
+        const extensionValue = (schema as Record<string, unknown>)[propertyName]
+        if (extensionValue && typeof extensionValue === 'string') {
+          return extensionValue
         }
-      })
+      }
+
+      // Check if property has const value
+      const propertySchema = schema.properties?.[propertyName] as SchemaObject
+      if (propertySchema && 'const' in propertySchema && propertySchema.const !== undefined) {
+        return String(propertySchema.const)
+      }
+
+      // Check if property has single enum value
+      if (propertySchema && propertySchema.enum?.length === 1) {
+        return String(propertySchema.enum[0])
+      }
+
+      // Fallback to title if available
+      return schema.title || null
     }
 
-    if (schema.anyOf) {
-      schema.anyOf.forEach((schema) => {
-        if (isReference(schema)) {
-          const key = this.getKey(schema.$ref)
-          const refSchema: OpenAPIV3.SchemaObject = this.get(schema.$ref)
-          // special case where enum in the schema is set without mapping being defined, see https://github.com/kubb-labs/kubb/issues/1669
-          const propertySchema = refSchema.properties?.[propertyName] as OpenAPIV3.SchemaObject
-          const canAdd = key && !Object.values(mapping).includes(schema.$ref)
-
-          if (canAdd && propertySchema?.enum?.length === 1) {
-            mapping[propertySchema.enum[0]] = schema.$ref
-          } else if (canAdd) {
-            mapping[key] = schema.$ref
+    /**
+     * Process oneOf/anyOf items to build mapping.
+     * Handles both $ref and inline schemas.
+     */
+    const processSchemas = (schemas: Array<SchemaObject>, existingMapping: Record<string, string>) => {
+      schemas.forEach((schemaItem, index) => {
+        if (isReference(schemaItem)) {
+          // Handle $ref case
+          const key = this.getKey(schemaItem.$ref)
+
+          try {
+            const refSchema = this.get<SchemaObject>(schemaItem.$ref)
+            const discriminatorValue = getDiscriminatorValue(refSchema)
+            const canAdd = key && !Object.values(existingMapping).includes(schemaItem.$ref)
+
+            if (canAdd && discriminatorValue) {
+              existingMapping[discriminatorValue] = schemaItem.$ref
+            } else if (canAdd) {
+              existingMapping[key] = schemaItem.$ref
+            }
+          } catch (_error) {
+            // If we can't resolve the reference, skip it and use the key as fallback
+            if (key && !Object.values(existingMapping).includes(schemaItem.$ref)) {
+              existingMapping[key] = schemaItem.$ref
+            }
+          }
+        } else {
+          // Handle inline schema case
+          const inlineSchema = schemaItem as SchemaObject
+          const discriminatorValue = getDiscriminatorValue(inlineSchema)
+
+          if (discriminatorValue) {
+            // Create a synthetic ref for inline schemas using index
+            // The value points to the inline schema itself via a special marker
+            existingMapping[discriminatorValue] = `#kubb-inline-${index}`
           }
         }
       })
     }
 
+    // Process oneOf schemas
+    if (schema.oneOf) {
+      processSchemas(schema.oneOf as Array<SchemaObject>, mapping)
+    }
+
+    // Process anyOf schemas
+    if (schema.anyOf) {
+      processSchemas(schema.anyOf as Array<SchemaObject>, mapping)
+    }
+
     return {
       ...schema.discriminator,
       mapping,
@@ -159,7 +206,7 @@ export class Oas<const TOAS = unknown> extends BaseOas {
   }
 
   // TODO add better typing
-  dereferenceWithRef(schema?: unknown) {
+  dereferenceWithRef<T = unknown>(schema?: T): T {
     if (isReference(schema)) {
       return {
         ...schema,
@@ -168,7 +215,7 @@ export class Oas<const TOAS = unknown> extends BaseOas {
       }
     }
 
-    return schema
+    return schema as T
   }
 
   #applyDiscriminatorInheritance() {
@@ -195,17 +242,17 @@ export class Oas<const TOAS = unknown> extends BaseOas {
       }
     }
 
-    const visit = (schema?: SchemaObject | OpenAPIV3.ReferenceObject | null) => {
+    const visit = (schema?: SchemaObject | ReferenceObject | null) => {
       if (!schema || typeof schema !== 'object') {
         return
       }
 
       if (isReference(schema)) {
-        visit(this.get(schema.$ref) as OpenAPIV3.SchemaObject)
+        visit(this.get(schema.$ref) as SchemaObject)
         return
       }
 
-      const schemaObject = schema as OpenAPIV3.SchemaObject
+      const schemaObject = schema as SchemaObject
 
       if (visited.has(schemaObject as object)) {
         return
@@ -314,7 +361,7 @@ export class Oas<const TOAS = unknown> extends BaseOas {
         const $ref = isReference(schema) ? schema.$ref : undefined
 
         if (schema && $ref) {
-          operation.schema.responses![key] = this.get($ref)
+          operation.schema.responses![key] = this.get<any>($ref)
         }
       })
     }
@@ -377,8 +424,11 @@ export class Oas<const TOAS = unknown> extends BaseOas {
 
     return params.reduce(
       (schema, pathParameters) => {
-        const property = pathParameters.content?.[contentType]?.schema ?? (pathParameters.schema as SchemaObject)
-        const required = [...(schema.required || ([] as any)), pathParameters.required ? pathParameters.name : undefined].filter(Boolean)
+        const property = (pathParameters.content?.[contentType]?.schema ?? (pathParameters.schema as SchemaObject)) as SchemaObject | null
+        const required =
+          typeof schema.required === 'boolean'
+            ? schema.required
+            : [...(schema.required || []), pathParameters.required ? pathParameters.name : undefined].filter(Boolean)
 
         // Handle explode=true with style=form for object with additionalProperties
         // According to OpenAPI spec, when explode is true, object properties are flattened
@@ -407,7 +457,7 @@ export class Oas<const TOAS = unknown> extends BaseOas {
             deprecated: schema.deprecated,
             example: property.example || schema.example,
             additionalProperties: property.additionalProperties,
-          }
+          } as SchemaObject
         }
 
         return {
@@ -423,13 +473,14 @@ export class Oas<const TOAS = unknown> extends BaseOas {
               ...property,
             },
           },
-        }
+        } as SchemaObject
       },
       { type: 'object', required: [], properties: {} } as SchemaObject,
     )
   }
 
   async valdiate() {
+    const OASNormalize = await import('oas-normalize').then((m) => m.default)
     const oasNormalize = new OASNormalize(this.api, {
       enablePaths: true,
       colorizeErrors: true,
@@ -446,9 +497,9 @@ export class Oas<const TOAS = unknown> extends BaseOas {
     })
   }
 
-  flattenSchema(schema?: SchemaObject): SchemaObject | undefined {
+  flattenSchema(schema: SchemaObject | null): SchemaObject | null {
     if (!schema?.allOf || schema.allOf.length === 0) {
-      return schema
+      return schema || null
     }
 
     // Never touch ref-based or structural composition
@@ -468,13 +519,12 @@ export class Oas<const TOAS = unknown> extends BaseOas {
 
     for (const fragment of schema.allOf as SchemaObject[]) {
       for (const [key, value] of Object.entries(fragment)) {
-        if ((merged as any)[key] === undefined) {
-          ;(merged as any)[key] = value
+        if (merged[key as keyof typeof merged] === undefined) {
+          merged[key as keyof typeof merged] = value
         }
       }
     }
 
-    // biome-ignore lint/suspicious/noAssignInExpressions: should not trigger this
     return merged
   }
 }

package/src/index.ts

@@ -1,5 +1,4 @@
 export { findSchemaDefinition, matchesMimeType } from 'oas/utils'
-export type { Infer, Model, RequestParams, Response } from './infer/index.ts'
 export { Oas } from './Oas.ts'
 export * from './types.ts'
 export {

package/src/types.ts

@@ -1,14 +1,23 @@
-import type * as OasTypes from 'oas/types'
-
 // external packages
-export type { Operation } from 'oas/operation'
+import type { Operation as OASOperation } from 'oas/operation'
+import type { OpenAPIV3 } from 'openapi-types'
+
 export type * as OasTypes from 'oas/types'
-export type { HttpMethods as HttpMethod } from 'oas/types'
+
+import type {
+  DiscriminatorObject as OASDiscriminatorObject,
+  OASDocument,
+  HttpMethods as OASHttpMethods,
+  MediaTypeObject as OASMediaTypeObject,
+  ResponseObject as OASResponseObject,
+  SchemaObject as OASSchemaObject,
+} from 'oas/types'
+
 export type { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
 
 export type contentType = 'application/json' | (string & {})
 
-export type SchemaObject = OasTypes.SchemaObject & {
+export type SchemaObject = OASSchemaObject & {
   'x-nullable'?: boolean
   $ref?: string
 }
@@ -22,4 +31,18 @@ export const HttpMethods = {
   HEAD: 'head',
   OPTIONS: 'options',
   TRACE: 'trace',
-} satisfies Record<Uppercase<OasTypes.HttpMethods>, OasTypes.HttpMethods>
+} satisfies Record<Uppercase<OASHttpMethods>, OASHttpMethods>
+
+export type HttpMethod = OASHttpMethods
+
+export type Document = OASDocument
+
+export type Operation = OASOperation
+
+export type DiscriminatorObject = OASDiscriminatorObject
+
+export type ReferenceObject = OpenAPIV3.ReferenceObject
+
+export type ResponseObject = OASResponseObject
+
+export type MediaTypeObject = OASMediaTypeObject

package/src/utils.ts

@@ -2,14 +2,14 @@ import path from 'node:path'
 import type { Config } from '@kubb/core'
 import { URLPath } from '@kubb/core/utils'
 import yaml from '@stoplight/yaml'
-import type * as OasTypes from 'oas/types'
-import type { OASDocument, ParameterObject, SchemaObject } from 'oas/types'
+import type { ParameterObject, SchemaObject } from 'oas/types'
 import { isRef, isSchema } from 'oas/types'
 import OASNormalize from 'oas-normalize'
-import type { OpenAPI, OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
+import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
 import { isPlainObject, mergeDeep } from 'remeda'
 import swagger2openapi from 'swagger2openapi'
 import { Oas } from './Oas.ts'
+import type { Document } from './types.ts'
 
 export const STRUCTURAL_KEYS = new Set(['properties', 'items', 'additionalProperties', 'oneOf', 'anyOf', 'allOf', 'not'])
 
@@ -81,7 +81,7 @@ export function isOptional(schema?: SchemaObject): boolean {
 }
 
 export async function parse(
-  pathOrApi: string | OASDocument,
+  pathOrApi: string | Document,
   { oasClass = Oas, canBundle = true, enablePaths = true }: { oasClass?: typeof Oas; canBundle?: boolean; enablePaths?: boolean } = {},
 ): Promise<Oas> {
   const { loadConfig, bundle } = await import('@redocly/openapi-core')
@@ -98,20 +98,20 @@ export async function parse(
     enablePaths,
     colorizeErrors: true,
   })
-  const document = (await oasNormalize.load()) as OpenAPI.Document
+  const document = (await oasNormalize.load()) as Document
 
   if (isOpenApiV2Document(document)) {
     const { openapi } = await swagger2openapi.convertObj(document, {
       anchors: true,
     })
 
-    return new oasClass({ oas: openapi as OASDocument })
+    return new oasClass(openapi as Document)
   }
 
-  return new oasClass({ oas: document })
+  return new oasClass(document)
 }
 
-export async function merge(pathOrApi: Array<string | OASDocument>, { oasClass = Oas }: { oasClass?: typeof Oas } = {}): Promise<Oas> {
+export async function merge(pathOrApi: Array<string | Document>, { oasClass = Oas }: { oasClass?: typeof Oas } = {}): Promise<Oas> {
   const instances = await Promise.all(pathOrApi.map((p) => parse(p, { oasClass, enablePaths: false, canBundle: false })))
 
   if (instances.length === 0) {
@@ -120,7 +120,7 @@ export async function merge(pathOrApi: Array<string | OASDocument>, { oasClass =
 
   const merged = instances.reduce(
     (acc, current) => {
-      return mergeDeep(acc, current.document as OASDocument)
+      return mergeDeep(acc, current.document as Document)
     },
     {
       openapi: '3.0.0',
@@ -141,7 +141,7 @@ export async function merge(pathOrApi: Array<string | OASDocument>, { oasClass =
 export function parseFromConfig(config: Config, oasClass: typeof Oas = Oas): Promise<Oas> {
   if ('data' in config.input) {
     if (typeof config.input.data === 'object') {
-      const api: OasTypes.OASDocument = structuredClone(config.input.data) as OasTypes.OASDocument
+      const api: Document = structuredClone(config.input.data) as Document
       return parse(api, { oasClass })
     }