@kubb/adapter-oas 5.0.0-alpha.14 → 5.0.0-alpha.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-alpha.14",
+  "version": "5.0.0-alpha.16",
   "description": "OpenAPI / Swagger adapter for Kubb — converts OAS input into a @kubb/ast RootNode.",
   "keywords": [
     "openapi",
@@ -46,8 +46,8 @@
     "openapi-types": "^12.1.3",
     "remeda": "^2.33.6",
     "swagger2openapi": "^7.0.8",
-    "@kubb/ast": "5.0.0-alpha.14",
-    "@kubb/core": "5.0.0-alpha.14"
+    "@kubb/ast": "5.0.0-alpha.16",
+    "@kubb/core": "5.0.0-alpha.16"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/adapter.ts

@@ -6,8 +6,8 @@ import { DEFAULT_PARSER_OPTIONS } from './constants.ts'
 import { resolveServerUrl } from './oas/resolveServerUrl.ts'
 import { parseFromConfig } from './oas/utils.ts'
 import { createOasParser } from './parser.ts'
+import { getImports } from './refResolver.ts'
 import type { OasAdapter } from './types.ts'
-import { getImports } from './utils.ts'
 
 export const adapterOasName = 'oas' satisfies OasAdapter['name']
 
@@ -37,7 +37,6 @@ export const adapterOas = createAdapter<OasAdapter>((options) => {
     serverIndex,
     serverVariables,
     discriminator = 'strict',
-    collisionDetection = true,
     dateType = DEFAULT_PARSER_OPTIONS.dateType,
     integerType = DEFAULT_PARSER_OPTIONS.integerType,
     unknownType = DEFAULT_PARSER_OPTIONS.unknownType,
@@ -58,7 +57,6 @@ export const adapterOas = createAdapter<OasAdapter>((options) => {
       serverIndex,
       serverVariables,
       discriminator,
-      collisionDetection,
       dateType,
       integerType,
       unknownType,
@@ -73,7 +71,7 @@ export const adapterOas = createAdapter<OasAdapter>((options) => {
       const fakeConfig = sourceToFakeConfig(source)
       const oas = await parseFromConfig(fakeConfig, oasClass)
 
-      oas.setOptions({ contentType, discriminator, collisionDetection })
+      oas.setOptions({ contentType, discriminator })
 
       if (validate) {
         try {
@@ -86,7 +84,7 @@ export const adapterOas = createAdapter<OasAdapter>((options) => {
       const server = serverIndex !== undefined ? oas.api.servers?.at(serverIndex) : undefined
       const baseURL = server?.url ? resolveServerUrl(server, serverVariables) : undefined
 
-      const parser = createOasParser(oas, { contentType, collisionDetection })
+      const parser = createOasParser(oas, { contentType })
       const root = parser.parse({ dateType, integerType, unknownType, emptySchemaType, enumSuffix })
 
       // This must happen after parse() because legacy enum remapping is finalized there.

package/src/constants.ts

@@ -1,5 +1,4 @@
 import type { SchemaType } from '@kubb/ast/types'
-import type { HttpMethods as OASHttpMethods } from 'oas/types'
 import type { ParserOptions } from './types.ts'
 
 /**
@@ -65,56 +64,8 @@ export const formatMap = {
   double: 'number',
 } as const satisfies Record<string, SchemaType>
 
-/**
- * Exhaustive list of media types that Kubb recognizes.
- */
-export const knownMediaTypes = new Set([
-  'application/json',
-  'application/xml',
-  'application/x-www-form-urlencoded',
-  'application/octet-stream',
-  'application/pdf',
-  'application/zip',
-  'application/graphql',
-  'multipart/form-data',
-  'text/plain',
-  'text/html',
-  'text/csv',
-  'text/xml',
-  'image/png',
-  'image/jpeg',
-  'image/gif',
-  'image/webp',
-  'image/svg+xml',
-  'audio/mpeg',
-  'video/mp4',
-] as const)
-
 /**
  * Vendor extension keys used to attach human-readable labels to enum values.
  * Checked in priority order: the first key found wins.
  */
 export const enumExtensionKeys = ['x-enumNames', 'x-enum-varnames'] as const
-
-/**
- * Scalar primitive schema types used for union member simplification.
- */
-export const SCALAR_PRIMITIVE_TYPES = new Set(['string', 'number', 'integer', 'bigint', 'boolean'] as const)
-
-/**
- * Canonical HTTP method names for the Kubb OAS layer.
- * Keys are uppercase (used in generated code); values are the lowercase strings
- * that the `oas` library uses internally.
- *
- * TODO(v5): remove — use `httpMethods` from `@kubb/ast`
- */
-export const httpMethods = {
-  GET: 'get',
-  POST: 'post',
-  PUT: 'put',
-  PATCH: 'patch',
-  DELETE: 'delete',
-  HEAD: 'head',
-  OPTIONS: 'options',
-  TRACE: 'trace',
-} as const satisfies Record<Uppercase<OASHttpMethods>, OASHttpMethods>

package/src/discriminator.ts

@@ -0,0 +1,25 @@
+import { createProperty, createSchema } from '@kubb/ast'
+import type { SchemaNode } from '@kubb/ast/types'
+
+export function resolveDiscriminatorValue(mapping: Record<string, string> | undefined, ref: string | undefined): string | undefined {
+  if (!mapping || !ref) return undefined
+  return Object.entries(mapping).find(([, value]) => value === ref)?.[0]
+}
+
+export function createDiscriminantNode(propertyName: string, value: string): SchemaNode {
+  return createSchema({
+    type: 'object',
+    primitive: 'object',
+    properties: [
+      createProperty({
+        name: propertyName,
+        schema: createSchema({
+          type: 'enum',
+          primitive: 'string',
+          enumValues: [value],
+        }),
+        required: true,
+      }),
+    ],
+  })
+}

package/src/infer.ts

@@ -0,0 +1,85 @@
+import type {
+  ArraySchemaNode,
+  DateSchemaNode,
+  DatetimeSchemaNode,
+  EnumSchemaNode,
+  IntersectionSchemaNode,
+  NumberSchemaNode,
+  ObjectSchemaNode,
+  RefSchemaNode,
+  ScalarSchemaNode,
+  SchemaNode,
+  StringSchemaNode,
+  TimeSchemaNode,
+  UnionSchemaNode,
+} from '@kubb/ast/types'
+import type { SchemaObject } from './oas/types.ts'
+import type { ParserOptions } from './types.ts'
+
+/**
+ * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
+ */
+type DateTimeNodeByDateType = {
+  date: DateSchemaNode
+  string: DatetimeSchemaNode
+  stringOffset: DatetimeSchemaNode
+  stringLocal: DatetimeSchemaNode
+  false: StringSchemaNode
+}
+
+/**
+ * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
+ */
+type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType
+  ? TDateType
+  : 'string']
+
+/**
+ * Single source of truth: ordered list of `[shape, SchemaNode]` pairs.
+ * `InferSchemaNode` walks this tuple in order and returns the node type of the first matching entry.
+ * Parameterized over `TDateType` so `format: 'date-time'` resolves to the correct node based on the option.
+ */
+type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [
+  [{ $ref: string }, RefSchemaNode],
+  [{ allOf: ReadonlyArray<unknown>; properties: object }, IntersectionSchemaNode],
+  [{ allOf: readonly [unknown, unknown, ...unknown[]] }, IntersectionSchemaNode],
+  [{ allOf: ReadonlyArray<unknown> }, SchemaNode],
+  [{ oneOf: ReadonlyArray<unknown> }, UnionSchemaNode],
+  [{ anyOf: ReadonlyArray<unknown> }, UnionSchemaNode],
+  [{ const: null }, ScalarSchemaNode],
+  [{ const: string | number | boolean }, EnumSchemaNode],
+  [{ type: ReadonlyArray<string> }, UnionSchemaNode],
+  [{ type: 'array'; enum: ReadonlyArray<unknown> }, ArraySchemaNode],
+  [{ enum: ReadonlyArray<unknown> }, EnumSchemaNode],
+  [{ type: 'object' }, ObjectSchemaNode],
+  [{ additionalProperties: boolean | {} }, ObjectSchemaNode],
+  [{ type: 'array' }, ArraySchemaNode],
+  [{ items: object }, ArraySchemaNode],
+  [{ prefixItems: ReadonlyArray<unknown> }, ArraySchemaNode],
+  [{ type: string; format: 'date-time' }, ResolveDateTimeNode<TDateType>],
+  [{ type: string; format: 'date' }, DateSchemaNode],
+  [{ type: string; format: 'time' }, TimeSchemaNode],
+  [{ format: 'date-time' }, ResolveDateTimeNode<TDateType>],
+  [{ format: 'date' }, DateSchemaNode],
+  [{ format: 'time' }, TimeSchemaNode],
+  [{ type: 'string' }, StringSchemaNode],
+  [{ type: 'number' }, NumberSchemaNode],
+  [{ type: 'integer' }, NumberSchemaNode],
+  [{ type: 'bigint' }, NumberSchemaNode],
+  [{ type: string }, ScalarSchemaNode],
+  [{ minLength: number }, StringSchemaNode],
+  [{ maxLength: number }, StringSchemaNode],
+  [{ pattern: string }, StringSchemaNode],
+  [{ minimum: number }, NumberSchemaNode],
+  [{ maximum: number }, NumberSchemaNode],
+]
+
+export type InferSchemaNode<
+  TSchema extends SchemaObject,
+  TDateType extends ParserOptions['dateType'] = 'string',
+  TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>,
+> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>]
+  ? TSchema extends TEntry[0]
+    ? TEntry[1]
+    : InferSchemaNode<TSchema, TDateType, TRest>
+  : SchemaNode

package/src/naming.ts

@@ -0,0 +1,25 @@
+import { pascalCase } from '@internals/utils'
+import { narrowSchema } from '@kubb/ast'
+import type { SchemaNode } from '@kubb/ast/types'
+
+export function resolveChildName(parentName: string | undefined, propName: string): string | undefined {
+  return parentName ? pascalCase([parentName, propName].join(' ')) : undefined
+}
+
+export function resolveEnumPropName(parentName: string | undefined, propName: string, enumSuffix: string): string {
+  return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))
+}
+
+export function applyEnumName(propNode: SchemaNode, parentName: string | undefined, propName: string, enumSuffix: string): SchemaNode {
+  const enumNode = narrowSchema(propNode, 'enum')
+
+  if (enumNode?.primitive === 'boolean') {
+    return { ...propNode, name: undefined }
+  }
+
+  if (enumNode) {
+    return { ...propNode, name: resolveEnumPropName(parentName, propName, enumSuffix) }
+  }
+
+  return propNode
+}

package/src/oas/Oas.ts

@@ -8,7 +8,6 @@ import {
   flattenSchema,
   isDiscriminator,
   isReference,
-  legacyResolve,
   resolveCollisions,
   type SchemaWithMetadata,
   sortSchemas,
@@ -25,11 +24,6 @@ const KUBB_INLINE_REF_PREFIX = '#kubb-inline-'
 type OasOptions = {
   contentType?: contentType
   discriminator?: 'strict' | 'inherit'
-  /**
-   * Resolve name collisions when schemas from different components share the same name (case-insensitive).
-   * @default false
-   */
-  collisionDetection?: boolean
 }
 
 export class Oas extends BaseOas {
@@ -541,13 +535,12 @@ export class Oas extends BaseOas {
    * Get schemas from OpenAPI components (schemas, responses, requestBodies).
    * Returns schemas in dependency order along with name mapping for collision resolution.
    */
-  getSchemas(options: { contentType?: contentType; includes?: Array<'schemas' | 'responses' | 'requestBodies'>; collisionDetection?: boolean } = {}): {
+  getSchemas(options: { contentType?: contentType; includes?: Array<'schemas' | 'responses' | 'requestBodies'> } = {}): {
     schemas: Record<string, SchemaObject>
     nameMapping: Map<string, string>
   } {
     const contentType = options.contentType ?? this.#options.contentType
     const includes = options.includes ?? ['schemas', 'requestBodies', 'responses']
-    const shouldResolveCollisions = options.collisionDetection ?? this.#options.collisionDetection ?? false
 
     const components = this.getDefinition().components
     const schemasWithMeta: SchemaWithMetadata[] = []
@@ -612,8 +605,7 @@ export class Oas extends BaseOas {
       }
     }
 
-    // Apply collision resolution only if enabled
-    const { schemas, nameMapping } = shouldResolveCollisions ? resolveCollisions(schemasWithMeta) : legacyResolve(schemasWithMeta)
+    const { schemas, nameMapping } = resolveCollisions(schemasWithMeta)
 
     return {
       schemas: sortSchemas(schemas),

package/src/oas/types.ts

@@ -1,9 +1,11 @@
 // external packages
+
+import { httpMethods } from '@kubb/ast'
+import type { HttpMethod as AstHttpMethod } from '@kubb/ast/types'
 import type { Operation as OASOperation } from 'oas/operation'
 import type {
   DiscriminatorObject as OASDiscriminatorObject,
   OASDocument,
-  HttpMethods as OASHttpMethods,
   MediaTypeObject as OASMediaTypeObject,
   ResponseObject as OASResponseObject,
   SchemaObject as OASSchemaObject,
@@ -52,11 +54,15 @@ export type SchemaObject = OASSchemaObject & {
 }
 
 /**
- * Re-exported from `constants.ts` for backwards compatibility.
+ * Canonical uppercase->lowercase HTTP method map.
+ * Re-exported for backwards compatibility with previous adapter-oas API.
  */
-export { httpMethods as HttpMethods } from '../constants.ts'
+export const HttpMethods = Object.fromEntries(Object.entries(httpMethods).map(([lower, upper]) => [upper, lower])) as Record<
+  Uppercase<AstHttpMethod>,
+  Lowercase<AstHttpMethod>
+>
 
-export type HttpMethod = OASHttpMethods
+export type HttpMethod = Lowercase<AstHttpMethod>
 
 export type Document = OASDocument