@kubb/adapter-oas 5.0.0-alpha.13 → 5.0.0-alpha.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-alpha.13",
+  "version": "5.0.0-alpha.15",
   "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.13",
-    "@kubb/core": "5.0.0-alpha.13"
+    "@kubb/ast": "5.0.0-alpha.15",
+    "@kubb/core": "5.0.0-alpha.15"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/adapter.ts

@@ -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/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/utils.ts

@@ -323,15 +323,14 @@ export function extractSchemaFromContent(content: Record<string, unknown> | unde
  * Returns the PascalCase suffix appended to a component name when resolving
  * cross-source name collisions (schemas vs. responses vs. requestBodies).
  */
+const semanticSuffixes: Record<SchemaSourceMode, string> = {
+  schemas: 'Schema',
+  responses: 'Response',
+  requestBodies: 'Request',
+}
+
 function getSemanticSuffix(source: SchemaSourceMode): string {
-  switch (source) {
-    case 'schemas':
-      return 'Schema'
-    case 'responses':
-      return 'Response'
-    case 'requestBodies':
-      return 'Request'
-  }
+  return semanticSuffixes[source]
 }
 
 /**

package/src/parser.ts

@@ -1,4 +1,4 @@
-import { getUniqueName, pascalCase, URLPath } from '@internals/utils'
+import { pascalCase, URLPath } from '@internals/utils'
 import { createOperation, createParameter, createProperty, createResponse, createRoot, createSchema, narrowSchema, schemaTypes, transform } from '@kubb/ast'
 import type {
   ArraySchemaNode,
@@ -121,7 +121,6 @@ export type InferSchemaNode<
  */
 export type OasParserOptions = {
   contentType?: contentType
-  collisionDetection?: boolean
 }
 
 /**
@@ -221,18 +220,10 @@ export type OasParser = {
  * const root = parser.parse({ emptySchemaType: 'unknown' })
  * ```
  */
-export function createOasParser(oas: Oas, { contentType, collisionDetection }: OasParserOptions = {}): OasParser {
+export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}): OasParser {
   // Map from original component paths to resolved schema names (after collision resolution)
   // e.g., { '#/components/schemas/Order': 'OrderSchema', '#/components/responses/Product': 'ProductResponse' }
-  const { schemas: schemaObjects, nameMapping } = oas.getSchemas({ contentType, collisionDetection })
-
-  // Legacy enum name deduplication: tracks used enum names and appends numeric suffixes
-  // (e.g. ParamsStatusEnum, ParamsStatusEnum2) when collisionDetection is disabled.
-  const usedEnumNames: Record<string, number> = {}
-
-  // Only apply legacy naming when collisionDetection is explicitly false.
-  // When undefined (e.g. direct parser usage without adapter), use the default (new) behavior.
-  const isLegacyNaming = collisionDetection === false
+  const { schemas: schemaObjects, nameMapping } = oas.getSchemas({ contentType })
 
   /**
    * Maps an `'any' | 'unknown' | 'void'` option string to the corresponding `SchemaType` constant.
@@ -478,7 +469,7 @@ export function createOasParser(oas: Oas, { contentType, collisionDetection }: O
 
       // Convert shared properties once to avoid duplicate enum naming
       // (e.g. StatusEnum appearing twice and getting a numeric suffix).
-      const sharedPropertiesNode = convertSchema({ schema: memberBaseSchema, name: isLegacyNaming ? undefined : name }, options)
+      const sharedPropertiesNode = convertSchema({ schema: memberBaseSchema, name }, options)
 
       return createSchema({
         type: 'union',
@@ -735,28 +726,21 @@ export function createOasParser(oas: Oas, { contentType, collisionDetection }: O
   /**
    * Builds the propagation name for a child property during recursive schema conversion.
    *
-   * - **Legacy naming** (`isLegacyNaming`): only the immediate property key is used
-   *   (e.g. `Params` for property `params`), keeping nested names short.
-   * - **Default naming**: the parent name is prepended so the full path is encoded
+   * The parent name is prepended so the full path is encoded
    *   (e.g. `OrderParams` when parent is `Order`).
    */
   function resolveChildName(parentName: string | undefined, propName: string): string | undefined {
-    if (isLegacyNaming) {
-      return pascalCase(propName)
-    }
     return parentName ? pascalCase([parentName, propName].join(' ')) : undefined
   }
 
   /**
    * Derives the final name for an enum property schema node.
    *
-   * The raw name always includes the enum suffix (e.g. `StatusEnum`).
-   * In legacy mode an additional deduplication step appends a numeric suffix
-   * when the same name has already been used (e.g. `ParamsStatusEnum2`).
+   * The resulting name always includes the enum suffix and full parent path context
+   * (e.g. `OrderParamsStatusEnum`).
    */
   function resolveEnumPropName(parentName: string | undefined, propName: string, enumSuffix: string): string {
-    const raw = pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))
-    return isLegacyNaming ? getUniqueName(raw, usedEnumNames) : raw
+    return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))
   }
 
   /**
@@ -804,8 +788,6 @@ export function createOasParser(oas: Oas, { contentType, collisionDetection }: O
             schema: {
               ...schemaNode,
               nullable: schemaNode.type === 'null' ? undefined : propNullable || undefined,
-              optional: !required && !propNullable ? true : undefined,
-              nullish: !required && propNullable ? true : undefined,
             },
             required,
           })
@@ -1078,7 +1060,6 @@ export function createOasParser(oas: Oas, { contentType, collisionDetection }: O
       schema: {
         ...schema,
         description: (param['description'] as string | undefined) ?? schema.description,
-        optional: !required || !!schema.optional ? true : undefined,
       },
       required,
     })

package/src/types.ts

@@ -66,16 +66,6 @@ export type OasAdapterOptions = {
    * @default 'strict'
    */
   discriminator?: 'strict' | 'inherit'
-  /**
-   * Enable collision detection for inline enum and schema type names.
-   * When `true` (default), full-path names are used and name collisions
-   * across schema components are automatically resolved (e.g. `OrderParamsStatusEnum`).
-   * When `false`, enum names use only the immediate property context
-   * (e.g. `ParamsStatusEnum`) matching the v4 naming conventions, with numeric
-   * suffixes for deduplication (e.g. `ParamsStatusEnum2`).
-   * @default true
-   */
-  collisionDetection?: boolean
   /**
    * How `format: 'date-time'` schemas are represented in the AST.
    * - `'string'` maps to a `datetime` string node.
@@ -92,7 +82,6 @@ export type OasAdapterResolvedOptions = {
   serverIndex: OasAdapterOptions['serverIndex']
   serverVariables: OasAdapterOptions['serverVariables']
   discriminator: NonNullable<OasAdapterOptions['discriminator']>
-  collisionDetection: boolean
   dateType: NonNullable<OasAdapterOptions['dateType']>
   integerType: NonNullable<OasAdapterOptions['integerType']>
   unknownType: NonNullable<OasAdapterOptions['unknownType']>