@kubb/adapter-oas 5.0.0-beta.17 → 5.0.0-beta.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-beta.17",
+  "version": "5.0.0-beta.19",
   "description": "OpenAPI and Swagger adapter for Kubb. Parses and validates OAS 2.0/3.x specifications into a @kubb/ast RootNode for downstream code generation plugins.",
   "keywords": [
     "adapter",
@@ -47,7 +47,7 @@
     "oas": "^32.1.18",
     "oas-normalize": "^16.0.4",
     "swagger2openapi": "^7.0.8",
-    "@kubb/core": "5.0.0-beta.17"
+    "@kubb/core": "5.0.0-beta.19"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/adapter.ts

@@ -58,6 +58,8 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
   let nameMapping = new Map<string, string>()
   let parsedDocument: Document | null = null
   let schemaObjects: ReturnType<typeof getSchemas>['schemas'] | null = null
+  let baseOasInstance: BaseOas | null = null
+  let schemaParserInstance: ReturnType<typeof createSchemaParser> | null = null
 
   function resolveBaseURL(document: Document): string | undefined {
     const server = serverIndex !== undefined ? document.servers?.at(serverIndex) : undefined
@@ -81,6 +83,16 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
     return schemaObjects
   }
 
+  function ensureBaseOas(document: Document): BaseOas {
+    if (!baseOasInstance) baseOasInstance = new BaseOas(document)
+    return baseOasInstance
+  }
+
+  function ensureSchemaParser(document: Document): ReturnType<typeof createSchemaParser> {
+    if (!schemaParserInstance) schemaParserInstance = createSchemaParser({ document, contentType })
+    return schemaParserInstance
+  }
+
   return {
     name: adapterOasName,
     get options() {
@@ -148,7 +160,7 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
       const document = await ensureDocument(source)
       const schemas = await ensureSchemas(document)
 
-      const baseOas = new BaseOas(document)
+      const baseOas = ensureBaseOas(document)
       const operationCount = Object.values(baseOas.getPaths()).flatMap(Object.values).filter(Boolean).length
 
       return { schemas: Object.keys(schemas).length, operations: operationCount }
@@ -157,30 +169,29 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
       const document = await ensureDocument(source)
       const schemas = await ensureSchemas(document)
 
-      let discriminatorChildMap: Awaited<ReturnType<typeof buildDiscriminatorChildMap>> | null = null
-      if (discriminator === 'inherit') {
-        const { parseSchema: _preParser } = createSchemaParser({ document, contentType })
+      const discriminatorChildMap: Awaited<ReturnType<typeof buildDiscriminatorChildMap>> | null = (() => {
+        if (discriminator !== 'inherit') return null
+        const { parseSchema: _preParser } = ensureSchemaParser(document)
         const parentNodes: ast.SchemaNode[] = []
         for (const [name, schema] of Object.entries(schemas)) {
           if ((schema.oneOf ?? schema.anyOf) && schema.discriminator?.propertyName) {
             parentNodes.push(_preParser({ schema, name }, parserOptions))
           }
         }
-        if (parentNodes.length > 0) {
-          discriminatorChildMap = buildDiscriminatorChildMap(parentNodes)
-        }
-      }
+        return parentNodes.length > 0 ? buildDiscriminatorChildMap(parentNodes) : null
+      })()
 
       // Each [Symbol.asyncIterator]() call returns a fresh generator so multiple
       // plugins can do independent `for await` passes without shared state.
+      // The underlying parser and BaseOas instance are cached at adapter scope.
       const schemasIterable: AsyncIterable<ast.SchemaNode> = {
         [Symbol.asyncIterator]() {
           return (async function* () {
-            const { parseSchema: _parseSchema } = createSchemaParser({ document, contentType })
+            const { parseSchema: _parseSchema } = ensureSchemaParser(document)
             for (const [name, schema] of Object.entries(schemas)) {
-              let node = _parseSchema({ schema, name }, parserOptions)
+              const parsedNode = _parseSchema({ schema, name }, parserOptions)
               const entry = discriminatorChildMap?.get(name)
-              if (entry) node = patchDiscriminatorNode(node, entry)
+              const node = entry ? patchDiscriminatorNode(parsedNode, entry) : parsedNode
               yield node
             }
           })()
@@ -190,8 +201,8 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
       const operationsIterable: AsyncIterable<ast.OperationNode> = {
         [Symbol.asyncIterator]() {
           return (async function* () {
-            const { parseOperation: _parseOperation } = createSchemaParser({ document, contentType })
-            const baseOas = new BaseOas(document)
+            const { parseOperation: _parseOperation } = ensureSchemaParser(document)
+            const baseOas = ensureBaseOas(document)
             const paths = baseOas.getPaths()
 
             for (const methods of Object.values(paths)) {

package/src/discriminator.ts

@@ -61,14 +61,11 @@ export function buildDiscriminatorChildMap(schemas: ast.SchemaNode[]): Map<strin
       if (!enumValues.length) continue
 
       const existing = childMap.get(refNode.name)
-      if (existing) {
-        existing.enumValues.push(...enumValues)
-      } else {
-        childMap.set(refNode.name, {
-          propertyName: discriminatorPropertyName,
-          enumValues: [...enumValues],
-        })
+      if (!existing) {
+        childMap.set(refNode.name, { propertyName: discriminatorPropertyName, enumValues: [...enumValues] })
+        continue
       }
+      existing.enumValues.push(...enumValues)
     }
   }
 

package/src/parser.ts

@@ -115,9 +115,7 @@ export function createSchemaParser(ctx: OasParserContext) {
     let resolvedSchema: ast.SchemaNode | undefined
     const refPath = schema.$ref
     if (refPath && !resolvingRefs.has(refPath)) {
-      if (resolvedRefCache.has(refPath)) {
-        resolvedSchema = resolvedRefCache.get(refPath)
-      } else {
+      if (!resolvedRefCache.has(refPath)) {
         try {
           const referenced = resolveRef<SchemaObject>(document, refPath)
           if (referenced) {
@@ -130,6 +128,7 @@ export function createSchemaParser(ctx: OasParserContext) {
         }
         resolvedRefCache.set(refPath, resolvedSchema)
       }
+      resolvedSchema = resolvedRefCache.get(refPath)
     }
 
     return ast.createSchema({
@@ -169,6 +168,7 @@ export function createSchemaParser(ctx: OasParserContext) {
         default: mergedDefault,
         example: schema.example ?? memberNode.example,
         pattern: schema.pattern ?? ('pattern' in memberNode ? memberNode.pattern : undefined),
+        format: schema.format ?? memberNode.format,
       } as ast.DistributiveOmit<ast.SchemaNode, 'kind'>)
     }
 
@@ -359,6 +359,7 @@ export function createSchemaParser(ctx: OasParserContext) {
         title: schema.title,
         description: schema.description,
         deprecated: schema.deprecated,
+        format: schema.format,
       })
     }
 
@@ -489,6 +490,7 @@ export function createSchemaParser(ctx: OasParserContext) {
       writeOnly: schema.writeOnly,
       default: enumDefault,
       example: schema.example,
+      format: schema.format,
     }
 
     const extensionKey = enumExtensionKeys.find((key) => key in schema)
@@ -536,15 +538,17 @@ export function createSchemaParser(ctx: OasParserContext) {
 
           const resolvedChildName = ast.childName(name, propName)
           const propNode = parseSchema({ schema: resolvedPropSchema, name: resolvedChildName }, rawOptions)
-          let schemaNode = ast.setEnumName(propNode, name, propName, options.enumSuffix)
-
-          const tupleNode = ast.narrowSchema(schemaNode, 'tuple')
-          if (tupleNode?.items) {
-            const namedItems = tupleNode.items.map((item) => ast.setEnumName(item, name, propName, options.enumSuffix))
-            if (namedItems.some((item, i) => item !== tupleNode.items![i])) {
-              schemaNode = { ...tupleNode, items: namedItems }
+          const schemaNode = (() => {
+            const node = ast.setEnumName(propNode, name, propName, options.enumSuffix)
+            const tupleNode = ast.narrowSchema(node, 'tuple')
+            if (tupleNode?.items) {
+              const namedItems = tupleNode.items.map((item) => ast.setEnumName(item, name, propName, options.enumSuffix))
+              if (namedItems.some((item, i) => item !== tupleNode.items![i])) {
+                return { ...tupleNode, items: namedItems }
+              }
             }
-          }
+            return node
+          })()
 
           return ast.createProperty({
             name: propName,
@@ -558,18 +562,15 @@ export function createSchemaParser(ctx: OasParserContext) {
       : []
 
     const additionalProperties = schema.additionalProperties
-    let additionalPropertiesNode: ast.SchemaNode | boolean | undefined
-    if (additionalProperties === true) {
-      additionalPropertiesNode = true
-    } else if (additionalProperties && Object.keys(additionalProperties).length > 0) {
-      additionalPropertiesNode = parseSchema({ schema: additionalProperties as SchemaObject }, rawOptions)
-    } else if (additionalProperties === false) {
-      additionalPropertiesNode = false
-    } else if (additionalProperties) {
-      additionalPropertiesNode = ast.createSchema({
-        type: typeOptionMap.get(options.unknownType)!,
-      })
-    }
+    const additionalPropertiesNode: ast.SchemaNode | boolean | undefined = (() => {
+      if (additionalProperties === true) return true
+      if (additionalProperties === false) return false
+      if (additionalProperties && Object.keys(additionalProperties).length > 0) {
+        return parseSchema({ schema: additionalProperties as SchemaObject }, rawOptions)
+      }
+      if (additionalProperties) return ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
+      return undefined
+    })()
 
     const rawPatternProperties = 'patternProperties' in schema ? schema.patternProperties : undefined
 
@@ -702,6 +703,7 @@ export function createSchemaParser(ctx: OasParserContext) {
       description: schema.description,
       deprecated: schema.deprecated,
       nullable,
+      format: schema.format,
     })
   }
 
@@ -795,6 +797,7 @@ export function createSchemaParser(ctx: OasParserContext) {
       name,
       title: schema.title,
       description: schema.description,
+      format: schema.format,
     })
   }
 

package/src/refs.ts

@@ -20,11 +20,8 @@ export function resolveRef<T = unknown>(document: Document, $ref: string): T | n
   if ($ref === '') {
     return null
   }
-  if ($ref.startsWith('#')) {
-    $ref = globalThis.decodeURIComponent($ref.substring(1))
-  } else {
-    return null
-  }
+  if (!$ref.startsWith('#')) return null
+  $ref = globalThis.decodeURIComponent($ref.substring(1))
 
   let docCache = _refCache.get(document)
   if (!docCache) {

package/src/resolvers.ts

@@ -314,13 +314,13 @@ function* collectRefs(schema: unknown): Generator<string, void, undefined> {
   if (schema && typeof schema === 'object') {
     for (const key in schema) {
       const value = (schema as Record<string, unknown>)[key]
-      if (key === '$ref' && typeof value === 'string') {
-        if (value.startsWith(SCHEMA_REF_PREFIX)) {
-          const name = value.slice(SCHEMA_REF_PREFIX.length)
-          if (name) yield name
-        }
-      } else {
+      if (!(key === '$ref' && typeof value === 'string')) {
         yield* collectRefs(value)
+        continue
+      }
+      if (value.startsWith(SCHEMA_REF_PREFIX)) {
+        const name = value.slice(SCHEMA_REF_PREFIX.length)
+        if (name) yield name
       }
     }
   }
@@ -512,6 +512,7 @@ export function buildSchemaNode(schema: SchemaObject, name: string | null | unde
     writeOnly: schema.writeOnly,
     default: defaultValue,
     example: schema.example,
+    format: schema.format,
   } as const
 }