@kubb/adapter-oas 5.0.0-beta.62 → 5.0.0-beta.64

package/src/discriminator.ts

@@ -1,132 +0,0 @@
-import { ast } from '@kubb/core'
-import type { SchemaNodeByType } from '@kubb/ast'
-
-export type DiscriminatorTarget = {
-  propertyName: string
-  enumValues: Array<string | number | boolean>
-}
-
-/**
- * Builds a map of child schema names → discriminator patch data by scanning the given
- * top-level AST schema nodes for union schemas that carry a `discriminatorPropertyName`.
- *
- * The streaming path calls this on a small pre-parsed subset of schemas (only the
- * discriminator parents) rather than on all schemas at once.
- */
-export function buildDiscriminatorChildMap(schemas: Array<ast.SchemaNode>): Map<string, DiscriminatorTarget> {
-  const childMap = new Map<string, DiscriminatorTarget>()
-
-  for (const schema of schemas) {
-    // Case 1: top-level schema is a union (oneOf/anyOf with discriminator)
-    // Case 2: top-level schema is an intersection wrapping a union (oneOf/anyOf + shared properties)
-    let unionNode = ast.narrowSchema(schema, 'union')
-
-    if (!unionNode) {
-      const intersectionMembers = ast.narrowSchema(schema, 'intersection')?.members
-      if (intersectionMembers) {
-        for (const m of intersectionMembers) {
-          const u = ast.narrowSchema(m, 'union')
-          if (u) {
-            unionNode = u
-            break
-          }
-        }
-      }
-    }
-
-    if (!unionNode?.discriminatorPropertyName || !unionNode.members) continue
-
-    const { discriminatorPropertyName, members } = unionNode
-
-    for (const member of members) {
-      // Members with a discriminant value are intersections: [RefSchemaNode, ObjectSchemaNode]
-      const intersectionNode = ast.narrowSchema(member, 'intersection')
-      if (!intersectionNode?.members) continue
-
-      let refNode: SchemaNodeByType['ref'] | null = null
-      let objNode: SchemaNodeByType['object'] | null = null
-
-      for (const m of intersectionNode.members) {
-        refNode ??= ast.narrowSchema(m, 'ref')
-        objNode ??= ast.narrowSchema(m, 'object')
-      }
-
-      if (!refNode?.name || !objNode) continue
-
-      const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName)
-      const enumNode = prop ? ast.narrowSchema(prop.schema, 'enum') : null
-      if (!enumNode?.enumValues?.length) continue
-
-      const enumValues = enumNode.enumValues.filter((v): v is string | number | boolean => v !== null)
-      if (!enumValues.length) continue
-
-      const existing = childMap.get(refNode.name)
-      if (!existing) {
-        childMap.set(refNode.name, { propertyName: discriminatorPropertyName, enumValues: [...enumValues] })
-        continue
-      }
-      existing.enumValues.push(...enumValues)
-    }
-  }
-
-  return childMap
-}
-
-/**
- * Patches a single top-level `SchemaNode` with its discriminator entry (adds or replaces
- * the discriminant property). Used by the streaming path to apply patches inline per yield
- * without buffering all schemas.
- */
-export function patchDiscriminatorNode(node: ast.SchemaNode, entry: { propertyName: string; enumValues: Array<string | number | boolean> }): ast.SchemaNode {
-  const objectNode = ast.narrowSchema(node, 'object')
-  if (!objectNode) return node
-
-  const { propertyName, enumValues } = entry
-  const enumSchema = ast.factory.createSchema({ type: 'enum', enumValues })
-  const newProp = ast.factory.createProperty({ name: propertyName, required: true, schema: enumSchema })
-
-  const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName)
-  const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => (i === existingIdx ? newProp : p)) : [...objectNode.properties, newProp]
-
-  return { ...objectNode, properties: newProperties }
-}
-
-/**
- * Creates a single-property object schema used as a discriminator literal.
- *
- * @example
- * ```ts
- * createDiscriminantNode({ propertyName: 'type', value: 'dog' })
- * // -> { type: 'object', properties: [{ name: 'type', required: true, schema: enum('dog') }] }
- * ```
- */
-export function createDiscriminantNode({ propertyName, value }: { propertyName: string; value: string }): ast.SchemaNode {
-  return ast.factory.createSchema({
-    type: 'object',
-    primitive: 'object',
-    properties: [
-      ast.factory.createProperty({
-        name: propertyName,
-        schema: ast.factory.createSchema({
-          type: 'enum',
-          primitive: 'string',
-          enumValues: [value],
-        }),
-        required: true,
-      }),
-    ],
-  })
-}
-
-/**
- * Returns the discriminator key whose mapping value matches `ref`, or `null` when there is no match.
- *
- * @example
- * ```ts
- * findDiscriminator({ dog: '#/components/schemas/Dog' }, '#/components/schemas/Dog') // 'dog'
- * ```
- */
-export function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null {
-  if (!mapping || !ref) return null
-  return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null
-}

package/src/factory.ts

@@ -1,180 +0,0 @@
-import path from 'node:path'
-import { exists, mergeDeep, Url } from '@internals/utils'
-import { Diagnostics } from '@kubb/core'
-import type { AdapterSource } from '@kubb/core'
-import { compileErrors, validate } from '@readme/openapi-parser'
-import { parse } from 'yaml'
-import { bundleDocument } from './bundler.ts'
-import { MERGE_DEFAULT_TITLE, MERGE_DEFAULT_VERSION, MERGE_OPENAPI_VERSION } from './constants.ts'
-import { isOpenApiV2Document } from './guards.ts'
-import type { Document } from './types.ts'
-
-export type ParseOptions = {
-  canBundle?: boolean
-}
-
-export 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 and URLs are
- * bundled via `api-ref-bundler`, hoisting external file schemas into named `components.schemas`
- * entries so generators can emit named types and imports. 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 })
- * ```
- */
-export async function parseDocument(pathOrApi: string | Document, { canBundle = true }: ParseOptions = {}): Promise<Document> {
-  if (typeof pathOrApi === 'string' && canBundle) {
-    const bundled = await bundleDocument(pathOrApi)
-
-    return parseDocument(bundled, { canBundle: false })
-  }
-
-  // A string here is always inline YAML/JSON content: file paths and URLs are read and parsed by
-  // `bundleDocument` first. `yaml.parse` also parses JSON, since JSON is a subset of YAML.
-  const document = (typeof pathOrApi === 'string' ? parse(pathOrApi) : pathOrApi) as Document
-
-  if (isOpenApiV2Document(document)) {
-    const { default: swagger2openapi } = await import('swagger2openapi')
-    const { openapi } = await swagger2openapi.convertObj(document, {
-      anchors: true,
-    })
-
-    return openapi as Document
-  }
-
-  return document
-}
-
-/**
- * Deep-merges multiple OpenAPI documents into a single `Document`.
- *
- * Each document is parsed independently, then deep-merged into one in array order.
- * Throws when the input array is empty.
- *
- * @example
- * ```ts
- * const document = await mergeDocuments(['./pets.yaml', './orders.yaml'])
- * ```
- */
-export async function mergeDocuments(pathOrApi: Array<string | Document>): Promise<Document> {
-  const documents = await Promise.all(pathOrApi.map((p) => parseDocument(p, { canBundle: false })))
-
-  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`.',
-      location: { kind: 'config' },
-    })
-  }
-
-  const seed: Document = {
-    openapi: MERGE_OPENAPI_VERSION,
-    info: { title: MERGE_DEFAULT_TITLE, version: MERGE_DEFAULT_VERSION },
-    paths: {},
-    components: { schemas: {} },
-  } as Document
-
-  const merged = documents.reduce(
-    (acc, current) => mergeDeep(acc as Record<string, unknown>, current as Record<string, unknown>),
-    seed as Record<string, unknown>,
-  )
-
-  return parseDocument(merged as 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",...}' })
- * ```
- */
-export async function parseFromConfig(source: AdapterSource): Promise<Document> {
-  if (source.type === 'data') {
-    if (typeof source.data === 'object') {
-      return parseDocument(structuredClone(source.data) as Document)
-    }
-
-    return parseDocument(source.data as string, { canBundle: false })
-  }
-
-  if (source.type === 'paths') {
-    return mergeDocuments(source.paths)
-  }
-
-  // type === 'path'
-  if (Url.canParse(source.path)) {
-    return parseDocument(source.path)
-  }
-
-  const resolved = path.resolve(path.dirname(source.path), source.path)
-  await assertInputExists(resolved)
-  return parseDocument(resolved)
-}
-
-/**
- * Throws a coded `KUBB_INPUT_NOT_FOUND` diagnostic when a local input path does not exist.
- * URLs are skipped, and a malformed but readable file is left for `parseDocument` to surface
- * its parse error instead.
- */
-export async function assertInputExists(input: string): Promise<void> {
-  if (Url.canParse(input)) {
-    return
-  }
-  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`.',
-      location: { kind: 'config' },
-    })
-  }
-}
-
-/**
- * Validates an OpenAPI document using `@readme/openapi-parser` with colorized error output.
- *
- * @example
- * ```ts
- * await validateDocument(document)
- * ```
- */
-export async function validateDocument(document: Document, { throwOnError = false }: ValidateDocumentOptions = {}): Promise<void> {
-  try {
-    // `validate` dereferences its input in place, so clone to keep the cached document intact.
-    const result = await validate(structuredClone(document), {
-      validate: {
-        errors: { colorize: true },
-      },
-    })
-
-    if (!result.valid) {
-      throw new Error(compileErrors(result))
-    }
-  } catch (error) {
-    if (throwOnError) {
-      throw error
-    }
-
-    // Validation failures are non-fatal, mirror plugin-oas behavior
-  }
-}

package/src/guards.ts

@@ -1,68 +0,0 @@
-import { isPlainObject } from '@internals/utils'
-import type { OpenAPIV2, OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
-import type { DiscriminatorObject, SchemaObject } from './types.ts'
-
-/**
- * Returns `true` when `doc` is a Swagger 2.0 document (no `openapi` key).
- *
- * @example
- * ```ts
- * if (isOpenApiV2Document(doc)) {
- *   // doc is OpenAPIV2.Document
- * }
- * ```
- */
-export function isOpenApiV2Document(doc: unknown): doc is OpenAPIV2.Document {
-  return !!doc && isPlainObject(doc) && !('openapi' in doc)
-}
-
-/**
- * Returns `true` when a schema should be treated as nullable.
- *
- * Recognizes all nullable signals across OAS versions: `nullable: true` (OAS 3.0),
- * `x-nullable: true` (vendor extension), `type: 'null'`, and `type: ['null', ...]` (OAS 3.1).
- *
- * @example
- * ```ts
- * isNullable({ type: 'string', nullable: true }) // true
- * isNullable({ type: ['string', 'null'] })       // true
- * isNullable({ type: 'string' })                 // false
- * ```
- */
-export function isNullable(schema?: SchemaObject & { 'x-nullable'?: boolean }): boolean {
-  const explicitNullable = schema?.nullable ?? schema?.['x-nullable']
-  if (explicitNullable === true) return true
-
-  const schemaType = schema?.type
-  if (schemaType === 'null') return true
-  if (Array.isArray(schemaType)) return schemaType.includes('null')
-
-  return false
-}
-
-/**
- * Returns `true` when `obj` is an OpenAPI `$ref` pointer object.
- *
- * @example
- * ```ts
- * isReference({ $ref: '#/components/schemas/Pet' }) // true
- * isReference({ type: 'string' })                   // false
- * ```
- */
-export function isReference(obj?: unknown): obj is OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject {
-  return !!obj && typeof obj === 'object' && '$ref' in obj
-}
-
-/**
- * Returns `true` when `obj` is a schema with a structured OAS 3.x `discriminator` object.
- *
- * @example
- * ```ts
- * isDiscriminator({ discriminator: { propertyName: 'type', mapping: {} } }) // true
- * isDiscriminator({ discriminator: 'type' })                                 // false (Swagger 2 string form)
- * ```
- */
-export function isDiscriminator(obj?: unknown): obj is SchemaObject & { discriminator: DiscriminatorObject } {
-  const record = obj as Record<string, unknown>
-  return !!obj && !!record['discriminator'] && typeof record['discriminator'] !== 'string'
-}

package/src/index.ts

@@ -1,15 +0,0 @@
-export { adapterOas, adapterOasName } from './adapter.ts'
-export type {
-  AdapterOas,
-  AdapterOasOptions,
-  AdapterOasResolvedOptions,
-  ContentType,
-  DiscriminatorObject,
-  Document,
-  HttpMethod,
-  MediaTypeObject,
-  Operation,
-  ReferenceObject,
-  ResponseObject,
-  SchemaObject,
-} from './types.ts'

package/src/mime.ts

@@ -1,22 +0,0 @@
-/**
- * MIME type fragments that mark a media type as JSON-like.
- *
- * Matches the substrings used by the `oas` library's `matchesMimeType.json`, so a content type is
- * JSON when it contains any of these. The `+json` entry catches structured-syntax suffixes such as
- * `application/vnd.api+json`.
- */
-const jsonMimeFragments = ['application/json', 'application/x-json', 'text/json', 'text/x-json', '+json'] as const
-
-/**
- * Returns `true` when a media type string is JSON-like.
- *
- * @example
- * ```ts
- * isJsonMimeType('application/json')         // true
- * isJsonMimeType('application/vnd.api+json') // true
- * isJsonMimeType('multipart/form-data')      // false
- * ```
- */
-export function isJsonMimeType(mimeType: string): boolean {
-  return jsonMimeFragments.some((fragment) => mimeType.includes(fragment))
-}

package/src/operation.ts

@@ -1,194 +0,0 @@
-import { SUPPORTED_METHODS } from './constants.ts'
-import { isReference } from './guards.ts'
-import { isJsonMimeType } from './mime.ts'
-import { resolveRef } from './refs.ts'
-import type { Document, MediaTypeObject, OperationObject, PathItemObject, ReferenceObject, RequestBodyObject, ResponseObject } from './types.ts'
-
-/**
- * A single OpenAPI operation: its URL path, HTTP method, and the raw operation object.
- *
- * `schema` is a live reference into the document, so any in-place `$ref` resolution the resolvers
- * perform is visible here too.
- */
-export type Operation = {
-  path: string
-  method: string
-  schema: OperationObject
-}
-
-/**
- * The document plus the operation being read. Shared by the request/response accessors so they can
- * resolve `$ref`s against the document.
- */
-type OperationContext = {
-  document: Document
-  operation: Operation
-}
-
-/**
- * Slugifies a path for the `operationId` fallback: non-alphanumerics collapse to single dashes,
- * with no leading or trailing dash.
- */
-function slugify(value: string): string {
-  return value
-    .replace(/[^a-zA-Z0-9]/g, '-')
-    .replace(/-{2,}/g, '-')
-    .replace(/^-|-$/g, '')
-}
-
-/**
- * Returns the operation's `operationId`, falling back to `<method>_<slugified-path>` when absent.
- */
-export function getOperationId({ path, method, schema }: Operation): string {
-  const { operationId } = schema
-  if (typeof operationId === 'string' && operationId.length > 0) {
-    return operationId
-  }
-  return `${method}_${slugify(path).toLowerCase()}`
-}
-
-/**
- * Returns the declared response status codes, skipping `x-` extensions and non-object entries.
- */
-export function getResponseStatusCodes({ schema }: Operation): Array<string> {
-  const responses = schema.responses as Record<string, unknown> | undefined
-  if (!responses || isReference(responses)) {
-    return []
-  }
-  return Object.keys(responses).filter((key) => !key.startsWith('x-') && !!responses[key] && typeof responses[key] === 'object')
-}
-
-/**
- * Returns the response object for a status code, resolving a `$ref` in place. `false` when absent.
- */
-export function getResponseByStatusCode({ document, operation, statusCode }: OperationContext & { statusCode: string | number }): ResponseObject | false {
-  const responses = operation.schema.responses as Record<string, ResponseObject | ReferenceObject> | undefined
-  if (!responses || isReference(responses)) {
-    return false
-  }
-  const response = responses[statusCode]
-  if (!response) {
-    return false
-  }
-  if (isReference(response)) {
-    const resolved = resolveRef<ResponseObject>(document, response.$ref)
-    responses[statusCode] = resolved as ResponseObject
-    if (!resolved || isReference(resolved)) {
-      return false
-    }
-    return resolved
-  }
-  return response
-}
-
-/**
- * Resolves the request body (dereferencing a `$ref` in place) and returns its content map, or
- * `undefined` when the operation has no request body.
- */
-function getRequestBodyContent({ document, operation }: OperationContext): Record<string, MediaTypeObject> | undefined {
-  const { schema } = operation
-  let requestBody = schema.requestBody as RequestBodyObject | ReferenceObject | undefined
-  if (!requestBody) {
-    return undefined
-  }
-  if (isReference(requestBody)) {
-    const resolved = resolveRef<RequestBodyObject>(document, requestBody.$ref)
-    ;(schema as { requestBody?: unknown }).requestBody = resolved
-    if (!resolved || isReference(resolved)) {
-      return undefined
-    }
-    requestBody = resolved
-  }
-  return requestBody.content
-}
-
-/**
- * Returns the request body media type. With `mediaType` set, returns that entry or `false`.
- * Otherwise picks the first JSON-like media type, then the first declared one, as a
- * `[mediaType, object]` tuple.
- */
-export function getRequestContent({
-  document,
-  operation,
-  mediaType,
-}: OperationContext & { mediaType?: string }): MediaTypeObject | false | [string, MediaTypeObject] {
-  const content = getRequestBodyContent({ document, operation })
-  if (!content) {
-    return false
-  }
-  if (mediaType) {
-    return mediaType in content ? content[mediaType]! : false
-  }
-  const mediaTypes = Object.keys(content)
-  const available = mediaTypes.find((mt) => isJsonMimeType(mt)) ?? mediaTypes[0]
-  return available ? [available, content[available]!] : false
-}
-
-/**
- * Returns the primary request content type. Prefers a JSON-like media type (the last one wins,
- * matching the previous behavior), then the first declared one, defaulting to `'application/json'`.
- */
-export function getRequestContentType({ document, operation }: OperationContext): string {
-  const content = getRequestBodyContent({ document, operation })
-  const mediaTypes = content ? Object.keys(content) : []
-
-  let result = mediaTypes[0] ?? 'application/json'
-  for (const mt of mediaTypes) {
-    if (isJsonMimeType(mt)) {
-      result = mt
-    }
-  }
-  return result
-}
-
-/**
- * Builds an `Operation` for every supported HTTP method on every path, in document order.
- * `x-` path keys and unresolvable path-item `$ref`s are skipped.
- *
- * @example
- * ```ts
- * for (const operation of getOperations(document)) {
- *   parseOperation(options, operation)
- * }
- * ```
- */
-export function getOperations(document: Document): Array<Operation> {
-  const operations: Array<Operation> = []
-  const paths = document.paths
-  if (!paths) {
-    return operations
-  }
-
-  for (const path of Object.keys(paths)) {
-    if (path.startsWith('x-')) {
-      continue
-    }
-
-    let pathItem = paths[path] as PathItemObject | ReferenceObject | undefined
-    if (!pathItem) {
-      continue
-    }
-    if (isReference(pathItem)) {
-      const resolved = resolveRef<PathItemObject>(document, pathItem.$ref)
-      ;(paths as Record<string, unknown>)[path] = resolved
-      if (!resolved || isReference(resolved)) {
-        continue
-      }
-      pathItem = resolved
-    }
-
-    const item = pathItem as Record<string, unknown>
-    for (const method of Object.keys(item)) {
-      if (!SUPPORTED_METHODS.has(method)) {
-        continue
-      }
-      const schema = item[method]
-      if (!schema || typeof schema !== 'object') {
-        continue
-      }
-      operations.push({ path, method, schema: schema as OperationObject })
-    }
-  }
-
-  return operations
-}