@kubb/plugin-oas 3.0.0-alpha.3 → 3.0.0-alpha.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-oas",
-  "version": "3.0.0-alpha.3",
+  "version": "3.0.0-alpha.31",
   "description": "Generator swagger",
   "keywords": [
     "typescript",
@@ -25,6 +25,11 @@
       "require": "./dist/index.cjs",
       "default": "./dist/index.cjs"
     },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
     "./utils": {
       "import": "./dist/utils.js",
       "require": "./dist/utils.cjs",
@@ -56,6 +61,9 @@
       ],
       "components": [
         "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
       ]
     }
   },
@@ -67,24 +75,22 @@
   ],
   "dependencies": {
     "@stoplight/yaml": "^4.3.0",
-    "remeda": "^2.11.0",
-    "@kubb/core": "3.0.0-alpha.3",
-    "@kubb/fs": "3.0.0-alpha.3",
-    "@kubb/oas": "3.0.0-alpha.3",
-    "@kubb/react": "3.0.0-alpha.3"
+    "remeda": "^2.14.0",
+    "@kubb/core": "3.0.0-alpha.31",
+    "@kubb/fs": "3.0.0-alpha.31",
+    "@kubb/oas": "3.0.0-alpha.31",
+    "@kubb/react": "3.0.0-alpha.31"
   },
   "devDependencies": {
-    "@types/react": "^18.3.4",
-    "@types/react-dom": "^18.3.0",
+    "@types/react": "^18.3.10",
     "react": "^18.3.1",
-    "tsup": "^8.2.4",
-    "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.3",
-    "@kubb/config-ts": "3.0.0-alpha.3",
-    "@kubb/config-tsup": "3.0.0-alpha.3"
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.2",
+    "@kubb/config-ts": "3.0.0-alpha.31",
+    "@kubb/config-tsup": "3.0.0-alpha.31"
   },
   "peerDependencies": {
-    "@kubb/react": "3.0.0-alpha.3"
+    "@kubb/react": "3.0.0-alpha.31"
   },
   "engines": {
     "node": ">=20"

package/src/OperationGenerator.ts

@@ -1,4 +1,4 @@
-import { type FileMetaBase, Generator } from '@kubb/core'
+import { BaseGenerator, type FileMetaBase } from '@kubb/core'
 import transformers from '@kubb/core/transformers'
 
 import type { PluginFactoryOptions, PluginManager } from '@kubb/core'
@@ -6,10 +6,13 @@ import type * as KubbFile from '@kubb/fs/types'
 
 import type { Plugin } from '@kubb/core'
 import type { HttpMethod, Oas, OasTypes, Operation, contentType } from '@kubb/oas'
+import type { Generator } from './generator.tsx'
 import type { Exclude, Include, OperationSchemas, OperationsByMethod, Override } from './types.ts'
-import type { Parser } from './parser.tsx'
 
-export type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never
+/**
+ * @deprecated
+ */
+export type GetOperationGeneratorOptions<T = any> = any
 
 export type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
 
@@ -28,10 +31,9 @@ type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
 }
 
 export class OperationGenerator<
-  TOptions = unknown,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TPluginOptions['resolvedOptions'], Context<TPluginOptions['resolvedOptions'], TPluginOptions>> {
   #operationsByMethod: OperationsByMethod = {}
   get operationsByMethod(): OperationsByMethod {
     return this.#operationsByMethod
@@ -41,7 +43,7 @@ export class OperationGenerator<
     this.#operationsByMethod = paths
   }
 
-  #getOptions(operation: Operation, method: HttpMethod): Partial<TOptions> {
+  #getOptions(operation: Operation, method: HttpMethod): Partial<TPluginOptions['resolvedOptions']> {
     const { override = [] } = this.context
 
     return (
@@ -67,10 +69,6 @@ export class OperationGenerator<
     )
   }
 
-  /**
-   *
-   * @deprecated
-   */
   #isExcluded(operation: Operation, method: HttpMethod): boolean {
     const { exclude = [] } = this.context
     let matched = false
@@ -96,10 +94,6 @@ export class OperationGenerator<
     return matched
   }
 
-  /**
-   *
-   * @deprecated
-   */
   #isIncluded(operation: Operation, method: HttpMethod): boolean {
     const { include = [] } = this.context
     let matched = false
@@ -128,10 +122,8 @@ export class OperationGenerator<
   getSchemas(
     operation: Operation,
     {
-      forStatusCode,
       resolveName = (name) => name,
     }: {
-      forStatusCode?: string | number
       resolveName?: (name: string) => string
     } = {},
   ): OperationSchemas {
@@ -139,8 +131,7 @@ export class OperationGenerator<
     const queryParamsSchema = this.context.oas.getParametersSchema(operation, 'query')
     const headerParamsSchema = this.context.oas.getParametersSchema(operation, 'header')
     const requestSchema = this.context.oas.getRequestSchema(operation)
-    const responseStatusCode =
-      forStatusCode || (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
+    const responseStatusCode = (operation.schema.responses && Object.keys(operation.schema.responses).find((key) => key.startsWith('2'))) || 200
     const responseSchema = this.context.oas.getResponseSchema(operation, responseStatusCode)
     const statusCodes = operation.getResponseStatusCodes().map((statusCode) => {
       let name = statusCode
@@ -226,7 +217,9 @@ export class OperationGenerator<
     }
   }
 
-  async build(...parsers: Array<Parser<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  #methods = ['get', 'post', 'patch', 'put', 'delete']
+
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas } = this.context
 
     const paths = oas.getPaths()
@@ -235,7 +228,7 @@ export class OperationGenerator<
 
       methods.forEach((method) => {
         const operation = oas.operation(path, method)
-        if (operation) {
+        if (operation && [this.#methods].some((methods) => method === operation.method)) {
           const isExcluded = this.#isExcluded(operation, method)
           const isIncluded = this.context.include ? this.#isIncluded(operation, method) : true
 
@@ -286,8 +279,8 @@ export class OperationGenerator<
           acc.push(promiseOperation)
         }
 
-        parsers?.forEach((parser) => {
-          const promise = parser.operation?.({
+        generators?.forEach((generator) => {
+          const promise = generator.operation?.({
             instance: this,
             operation,
             options: {
@@ -309,8 +302,8 @@ export class OperationGenerator<
 
     promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod))
 
-    parsers?.forEach((parser) => {
-      const promise = parser.operations?.({
+    generators?.forEach((generator) => {
+      const promise = generator.operations?.({
         instance: this,
         operations: operations.flat().filter(Boolean),
         operationsByMethod: this.operationsByMethod,
@@ -331,41 +324,41 @@ export class OperationGenerator<
   /**
    * Operation
    */
-  async operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async operation(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * GET
    */
-  async get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async get(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * POST
    */
-  async post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async post(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
   /**
    * PATCH
    */
-  async patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async patch(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * PUT
    */
-  async put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async put(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 
   /**
    * DELETE
    */
-  async delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
+  async delete(operation: Operation, options: TPluginOptions['resolvedOptions']): OperationMethodResult<TFileMeta> {
     return []
   }
 

package/src/SchemaGenerator.ts

@@ -1,4 +1,4 @@
-import { type FileMetaBase, Generator } from '@kubb/core'
+import { BaseGenerator, type FileMetaBase } from '@kubb/core'
 import transformers, { pascalCase } from '@kubb/core/transformers'
 import { getUniqueName } from '@kubb/core/utils'
 
@@ -13,8 +13,8 @@ import type * as KubbFile from '@kubb/fs/types'
 
 import type { Oas, OpenAPIV3, SchemaObject, contentType } from '@kubb/oas'
 import type { Schema, SchemaKeywordMapper } from './SchemaMapper.ts'
+import type { Generator } from './generator.tsx'
 import type { OperationSchema, Override, Refs } from './types.ts'
-import type { Parser } from './parser.tsx'
 
 export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
 
@@ -68,7 +68,7 @@ export class SchemaGenerator<
   TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
   // Collect the types of all referenced schemas, so we can export them later
   refs: Refs = {}
 
@@ -302,7 +302,7 @@ export class SchemaGenerator<
 
     if (additionalProperties) {
       additionalPropertiesSchemas =
-        additionalProperties === true
+        additionalProperties === true || !Object.keys(additionalProperties).length
           ? [{ keyword: this.#getUnknownReturn({ schema, name }) }]
           : this.parse({ schema: additionalProperties as SchemaObject, parentName: name })
     }
@@ -349,7 +349,7 @@ export class SchemaGenerator<
     const file = this.context.pluginManager.getFile({
       name: fileName,
       pluginKey: this.context.plugin.key,
-      extName: '.ts',
+      extname: '.ts',
     })
 
     ref = this.refs[$ref] = {
@@ -361,7 +361,7 @@ export class SchemaGenerator<
     return [
       {
         keyword: schemaKeywords.ref,
-        args: { name: ref.propertyName, path: ref?.path, isTypeOnly: false },
+        args: { name: ref.propertyName, path: ref?.path },
       },
     ]
   }
@@ -379,12 +379,6 @@ export class SchemaGenerator<
     const options = this.#getOptions({ schema: _schema, name })
     const unknownReturn = this.#getUnknownReturn({ schema: _schema, name })
     const { schema, version } = this.#getParsedSchemaObject(_schema)
-    const resolvedName = this.context.pluginManager.resolveName({
-      name: `${parentName || ''} ${name}`,
-      pluginKey: this.context.plugin.key,
-      type: 'type',
-    })
-
     if (!schema) {
       return [{ keyword: unknownReturn }]
     }
@@ -408,12 +402,16 @@ export class SchemaGenerator<
           keyword: schemaKeywords.default,
           args: transformers.stringify(schema.default),
         })
-      }
-      if (typeof schema.default === 'boolean') {
+      } else if (typeof schema.default === 'boolean') {
         baseItems.push({
           keyword: schemaKeywords.default,
           args: schema.default ?? false,
         })
+      } else {
+        baseItems.push({
+          keyword: schemaKeywords.default,
+          args: schema.default,
+        })
       }
     }
 
@@ -455,10 +453,16 @@ export class SchemaGenerator<
       baseItems.push({ keyword: schemaKeywords.readOnly })
     }
 
+    if (schema.writeOnly) {
+      baseItems.push({ keyword: schemaKeywords.writeOnly })
+    }
+
     if (isReference(schema)) {
       return [
         ...this.#getRefAlias(schema),
         nullable && { keyword: schemaKeywords.nullable },
+        schema.readOnly && { keyword: schemaKeywords.readOnly },
+        schema.writeOnly && { keyword: schemaKeywords.writeOnly },
         {
           keyword: schemaKeywords.schema,
           args: {
@@ -485,7 +489,20 @@ export class SchemaGenerator<
           }),
       }
       if (schemaWithoutOneOf.properties) {
-        return [...this.parse({ schema: schemaWithoutOneOf, name, parentName }), union, ...baseItems]
+        const propertySchemas = this.parse({ schema: schemaWithoutOneOf, name, parentName })
+
+        return [
+          {
+            ...union,
+            args: union.args.map((arg) => {
+              return {
+                keyword: schemaKeywords.and,
+                args: [arg, ...propertySchemas],
+              }
+            }),
+          },
+          ...baseItems,
+        ]
       }
 
       return [union, ...baseItems]
@@ -620,6 +637,35 @@ export class SchemaGenerator<
         ]
       }
 
+      if (schema.type === 'boolean') {
+        // we cannot use z.enum when enum type is boolean
+        const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum)) as unknown as SchemaKeywordMapper['enum']
+        return [
+          {
+            keyword: schemaKeywords.enum,
+            args: {
+              name: enumName,
+              typeName,
+              asConst: true,
+              items: enumNames?.args?.items
+                ? [...new Set(enumNames.args.items)].map(({ name, value }) => ({
+                    name,
+                    value,
+                    format: 'boolean',
+                  }))
+                : [...new Set(filteredValues)].map((value: string) => {
+                    return {
+                      name: value,
+                      value,
+                      format: 'boolean',
+                    }
+                  }),
+            },
+          },
+          ...baseItems.filter((item) => item.keyword !== schemaKeywords.matches),
+        ]
+      }
+
       if (extensionEnums.length > 0 && extensionEnums[0]) {
         return extensionEnums[0]
       }
@@ -810,7 +856,7 @@ export class SchemaGenerator<
         ].filter(Boolean)
       }
 
-      if (!['boolean', 'object', 'number', 'string', 'integer'].includes(schema.type)) {
+      if (!['boolean', 'object', 'number', 'string', 'integer', 'null'].includes(schema.type)) {
         this.context.pluginManager.logger.emit('warning', `Schema type '${schema.type}' is not valid for schema ${parentName}.${name}`)
       }
 
@@ -821,14 +867,20 @@ export class SchemaGenerator<
     return [{ keyword: unknownReturn }]
   }
 
-  async build(...parsers: Array<Parser<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<TPluginOptions>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
+    oas.resolveDiscriminators()
+
     const schemas = getSchemas({ oas, contentType, includes: include })
 
-    const promises = Object.entries(schemas).reduce((acc, [name, schema]) => {
+    const promises = Object.entries(schemas).reduce((acc, [name, value]) => {
+      if (!value) {
+        return acc
+      }
+
       const options = this.#getOptions({ name })
-      const promiseOperation = this.schema.call(this, name, schema, {
+      const promiseOperation = this.schema.call(this, name, value, {
         ...this.options,
         ...options,
       })
@@ -837,11 +889,16 @@ export class SchemaGenerator<
         acc.push(promiseOperation)
       }
 
-      parsers?.forEach((parser) => {
-        const promise = parser.schema?.({
+      generators?.forEach((generator) => {
+        const tree = this.parse({ schema: value, name: name })
+
+        const promise = generator.schema?.({
           instance: this,
-          name,
-          schema,
+          schema: {
+            name,
+            value,
+            tree,
+          },
           options: {
             ...this.options,
             ...options,

package/src/SchemaMapper.ts

@@ -12,6 +12,7 @@ export type SchemaKeywordMapper = {
   strict: { keyword: 'strict' }
   url: { keyword: 'url' }
   readOnly: { keyword: 'readOnly' }
+  writeOnly: { keyword: 'writeOnly' }
   uuid: { keyword: 'uuid' }
   email: { keyword: 'email' }
   firstName: { keyword: 'firstName' }
@@ -34,8 +35,8 @@ export type SchemaKeywordMapper = {
       asConst: boolean
       items: Array<{
         name: string | number
-        format: 'string' | 'number'
-        value?: string | number
+        format: 'string' | 'number' | 'boolean'
+        value?: string | number | boolean
       }>
     }
   }
@@ -44,14 +45,14 @@ export type SchemaKeywordMapper = {
     keyword: 'const'
     args: {
       name: string | number
-      format: 'string' | 'number'
-      value?: string | number
+      format: 'string' | 'number' | 'boolean'
+      value?: string | number | boolean
     }
   }
   union: { keyword: 'union'; args: Schema[] }
   ref: {
     keyword: 'ref'
-    args: { name: string; path: KubbFile.OptionalPath; isTypeOnly?: boolean }
+    args: { name: string; path: KubbFile.OptionalPath }
   }
   matches: { keyword: 'matches'; args?: string }
   boolean: { keyword: 'boolean' }
@@ -107,6 +108,7 @@ export const schemaKeywords = {
   max: 'max',
   optional: 'optional',
   readOnly: 'readOnly',
+  writeOnly: 'writeOnly',
 
   // custom ones
   object: 'object',

package/src/components/Oas.tsx

@@ -4,7 +4,7 @@ import { Operation } from './Operation.tsx'
 import { Schema } from './Schema.tsx'
 
 import type { Oas as OasType, Operation as OperationType } from '@kubb/oas'
-import type { KubbNode } from '@kubb/react'
+import type { KubbNode } from '@kubb/react/types'
 import type { OperationGenerator } from '../OperationGenerator.ts'
 
 type Props = {

package/src/components/Operation.tsx

@@ -1,7 +1,7 @@
 import { createContext } from '@kubb/react'
 
 import type { Operation as OperationType } from '@kubb/oas'
-import type { KubbNode } from '@kubb/react'
+import type { KubbNode } from '@kubb/react/types'
 
 type Props = {
   operation: OperationType

package/src/components/Schema.tsx

@@ -1,15 +1,8 @@
-import { File, Parser, createContext, useApp, useFile } from '@kubb/react'
+import { createContext } from '@kubb/react'
 
-import { schemaKeywords } from '../SchemaMapper.ts'
-import { useSchema } from '../hooks/useSchema.ts'
-
-import type * as KubbFile from '@kubb/fs/types'
 import type { SchemaObject } from '@kubb/oas'
-import type { KubbNode } from '@kubb/react'
-import type { ReactNode } from 'react'
-import { SchemaGenerator } from '../SchemaGenerator.ts'
+import type { KubbNode } from '@kubb/react/types'
 import type { Schema as SchemaType } from '../SchemaMapper.ts'
-import type { PluginOas } from '../types.ts'
 
 export type SchemaContextProps = {
   name: string
@@ -33,97 +26,4 @@ export function Schema({ name, value, tree = [], children }: Props): KubbNode {
   return <SchemaContext.Provider value={{ name, schema: value, tree }}>{children}</SchemaContext.Provider>
 }
 
-type FileProps = {
-  isTypeOnly?: boolean
-  output: string | undefined
-  children?: KubbNode
-}
-
-Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode {
-  const { plugin, pluginManager, mode } = useApp<PluginOas>()
-  const { name } = useSchema()
-
-  if (mode === 'single') {
-    const baseName = output as KubbFile.BaseName
-    const resolvedPath = pluginManager.resolvePath({
-      baseName: '',
-      pluginKey: plugin.key,
-    })
-
-    if (!resolvedPath) {
-      return null
-    }
-
-    return (
-      <Parser language="typescript">
-        <File
-          baseName={baseName}
-          path={resolvedPath}
-          meta={{
-            pluginKey: plugin.key,
-          }}
-        >
-          {children}
-        </File>
-      </Parser>
-    )
-  }
-
-  const baseName = `${pluginManager.resolveName({
-    name,
-    pluginKey: plugin.key,
-    type: 'file',
-  })}.ts` as const
-  const resolvedPath = pluginManager.resolvePath({
-    baseName,
-    pluginKey: plugin.key,
-  })
-
-  if (!resolvedPath) {
-    return null
-  }
-
-  return (
-    <Parser language="typescript">
-      <File
-        baseName={baseName}
-        path={resolvedPath}
-        meta={{
-          pluginKey: plugin.key,
-        }}
-      >
-        <Schema.Imports isTypeOnly={isTypeOnly} />
-        {children}
-      </File>
-    </Parser>
-  )
-}
-
-type SchemaImportsProps = {
-  isTypeOnly?: boolean
-  extName?: KubbFile.Extname
-}
-
-Schema.Imports = ({ isTypeOnly, extName }: SchemaImportsProps): ReactNode => {
-  const { tree } = useSchema()
-  const { path: root } = useFile()
-
-  const refs = SchemaGenerator.deepSearch(tree, schemaKeywords.ref)
-
-  return (
-    <>
-      {refs
-        ?.map((item, i) => {
-          if (!item.args.path) {
-            return undefined
-          }
-
-          return (
-            <File.Import key={i} extName={extName} root={root} name={[item.args.name]} path={item.args.path} isTypeOnly={item.args.isTypeOnly ?? isTypeOnly} />
-          )
-        })
-        .filter(Boolean)}
-    </>
-  )
-}
 Schema.Context = SchemaContext