@kubb/plugin-oas 3.0.0-alpha.0 → 3.0.0-alpha.10

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,8 +6,12 @@ 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'
 
+/**
+ * @deprecated
+ */
 export type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never
 
 export type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>
@@ -26,11 +30,11 @@ type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
   mode: KubbFile.Mode
 }
 
-export abstract class OperationGenerator<
+export class OperationGenerator<
   TOptions = unknown,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
-> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
+> extends BaseGenerator<TOptions, Context<TOptions, TPluginOptions>> {
   #operationsByMethod: OperationsByMethod = {}
   get operationsByMethod(): OperationsByMethod {
     return this.#operationsByMethod
@@ -65,6 +69,7 @@ export abstract class OperationGenerator<
       })?.options || {}
     )
   }
+
   /**
    *
    * @deprecated
@@ -93,6 +98,7 @@ export abstract class OperationGenerator<
 
     return matched
   }
+
   /**
    *
    * @deprecated
@@ -124,7 +130,13 @@ export abstract class OperationGenerator<
 
   getSchemas(
     operation: Operation,
-    { forStatusCode, resolveName = (name) => name }: { forStatusCode?: string | number; resolveName?: (name: string) => string } = {},
+    {
+      forStatusCode,
+      resolveName = (name) => name,
+    }: {
+      forStatusCode?: string | number
+      resolveName?: (name: string) => string
+    } = {},
   ): OperationSchemas {
     const pathParamsSchema = this.context.oas.getParametersSchema(operation, 'path')
     const queryParamsSchema = this.context.oas.getParametersSchema(operation, 'query')
@@ -217,20 +229,9 @@ export abstract class OperationGenerator<
     }
   }
 
-  get #methods() {
-    return {
-      get: this.get,
-      post: this.post,
-      patch: this.patch,
-      put: this.put,
-      delete: this.delete,
-      head: undefined,
-      options: undefined,
-      trace: undefined,
-    } as const
-  }
+  #methods = ['get', 'post', 'patch', 'put', 'delete']
 
-  async build(): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas } = this.context
 
     const paths = oas.getPaths()
@@ -239,7 +240,7 @@ export abstract class OperationGenerator<
 
       methods.forEach((method) => {
         const operation = oas.operation(path, method)
-        if (operation && this.#methods[method]) {
+        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
 
@@ -267,21 +268,43 @@ export abstract class OperationGenerator<
       methods.forEach((method) => {
         const { operation } = this.operationsByMethod[path]?.[method]!
         const options = this.#getOptions(operation, method)
-        const promiseMethod = this.#methods[method]?.call(this, operation, {
-          ...this.options,
-          ...options,
-        })
+
+        const methodToCall = this[method as keyof typeof this] as any
+
+        if (typeof methodToCall === 'function') {
+          const promiseMethod = methodToCall?.call(this, operation, {
+            ...this.options,
+            ...options,
+          })
+
+          if (promiseMethod) {
+            acc.push(promiseMethod)
+          }
+        }
+
         const promiseOperation = this.operation.call(this, operation, {
           ...this.options,
           ...options,
         })
 
-        if (promiseMethod) {
-          acc.push(promiseMethod)
-        }
         if (promiseOperation) {
           acc.push(promiseOperation)
         }
+
+        generators?.forEach((generator) => {
+          const promise = generator.operation?.({
+            instance: this,
+            operation,
+            options: {
+              ...this.options,
+              ...options,
+            },
+          } as any) as Promise<Array<KubbFile.File<TFileMeta>>>
+
+          if (promise) {
+            acc.push(promise)
+          }
+        })
       })
 
       return acc
@@ -291,6 +314,19 @@ export abstract class OperationGenerator<
 
     promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod))
 
+    generators?.forEach((generator) => {
+      const promise = generator.operations?.({
+        instance: this,
+        operations: operations.flat().filter(Boolean),
+        operationsByMethod: this.operationsByMethod,
+        options: this.options,
+      } as any) as Promise<Array<KubbFile.File<TFileMeta>>>
+
+      if (promise) {
+        promises.push(promise)
+      }
+    })
+
     const files = await Promise.all(promises)
 
     // using .flat because operationGenerator[method] can return a array of files or just one file
@@ -301,47 +337,47 @@ export abstract class OperationGenerator<
    * Operation
    */
   async operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
 
   /**
    * GET
    */
   async get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
 
   /**
    * POST
    */
   async post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
   /**
    * PATCH
    */
   async patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
 
   /**
    * PUT
    */
   async put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
 
   /**
    * DELETE
    */
   async delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta> {
-    return null
+    return []
   }
 
   /**
    * Combination of GET, POST, PATCH, PUT, DELETE
    */
   async all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta> {
-    return null
+    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,6 +13,7 @@ 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'
 
 export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
@@ -63,11 +64,11 @@ type SchemaProps = {
   parentName?: string
 }
 
-export abstract class SchemaGenerator<
+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 = {}
 
@@ -360,7 +361,7 @@ export abstract class SchemaGenerator<
     return [
       {
         keyword: schemaKeywords.ref,
-        args: { name: ref.propertyName, path: ref?.path, isTypeOnly: false },
+        args: { name: ref.propertyName, path: ref?.path },
       },
     ]
   }
@@ -378,12 +379,6 @@ export abstract 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 }]
     }
@@ -407,12 +402,16 @@ export abstract 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,
+        })
       }
     }
 
@@ -820,7 +819,7 @@ export abstract class SchemaGenerator<
     return [{ keyword: unknownReturn }]
   }
 
-  async build(): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...generators: Array<Generator<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
     const schemas = getSchemas({ oas, contentType, includes: include })
@@ -836,17 +835,35 @@ export abstract class SchemaGenerator<
         acc.push(promiseOperation)
       }
 
+      generators?.forEach((generator) => {
+        const promise = generator.schema?.({
+          instance: this,
+          name,
+          schema,
+          options: {
+            ...this.options,
+            ...options,
+          },
+        } as any) as Promise<Array<KubbFile.File<TFileMeta>>>
+
+        if (promise) {
+          acc.push(promise)
+        }
+      })
+
       return acc
     }, [] as SchemaMethodResult<TFileMeta>[])
 
     const files = await Promise.all(promises)
 
-    // using .flat because schemaGenerator[method] can return a array of files or just one file
+    // using .flat because schemaGenerator[method] can return an array of files or just one file
     return files.flat().filter(Boolean)
   }
 
   /**
    * Schema
    */
-  abstract schema(name: string, object: SchemaObject, options: TOptions): SchemaMethodResult<TFileMeta>
+  async schema(name: string, object: SchemaObject, options: TOptions): SchemaMethodResult<TFileMeta> {
+    return []
+  }
 }

package/src/SchemaMapper.ts

@@ -51,7 +51,7 @@ export type SchemaKeywordMapper = {
   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' }

package/src/components/Oas.tsx

@@ -4,20 +4,26 @@ 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 = {
   oas: OasType
   operations?: OperationType[]
-  generator?: OperationGenerator
+  /**
+   * @deprecated
+   */
+  generator?: Omit<OperationGenerator, 'build'>
   children?: KubbNode
 }
 
 type OasContextProps = {
   oas?: OasType
   operations?: OperationType[]
-  generator?: OperationGenerator
+  /**
+   * @deprecated
+   */
+  generator?: Omit<OperationGenerator, 'build'>
 }
 
 const OasContext = createContext<OasContextProps>({})

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,11 +1,11 @@
-import { File, Parser, createContext, useApp, useFile } from '@kubb/react'
+import { File, createContext, useApp, useFile } 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 { KubbNode } from '@kubb/react/types'
 import type { ReactNode } from 'react'
 import { SchemaGenerator } from '../SchemaGenerator.ts'
 import type { Schema as SchemaType } from '../SchemaMapper.ts'
@@ -44,7 +44,12 @@ Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode
   const { name } = useSchema()
 
   if (mode === 'single') {
-    const baseName = output as KubbFile.BaseName
+    const baseName = `${pluginManager.resolveName({
+      name,
+      pluginKey: plugin.key,
+      type: 'file',
+    })}.ts` as const
+
     const resolvedPath = pluginManager.resolvePath({
       baseName: '',
       pluginKey: plugin.key,
@@ -55,17 +60,15 @@ Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode
     }
 
     return (
-      <Parser language="typescript">
-        <File
-          baseName={baseName}
-          path={resolvedPath}
-          meta={{
-            pluginKey: plugin.key,
-          }}
-        >
-          {children}
-        </File>
-      </Parser>
+      <File
+        baseName={baseName}
+        path={resolvedPath}
+        meta={{
+          pluginKey: plugin.key,
+        }}
+      >
+        {children}
+      </File>
     )
   }
 
@@ -84,27 +87,24 @@ Schema.File = function ({ output, isTypeOnly, children }: FileProps): ReactNode
   }
 
   return (
-    <Parser language="typescript">
-      <File
-        baseName={baseName}
-        path={resolvedPath}
-        meta={{
-          pluginKey: plugin.key,
-        }}
-      >
-        <Schema.Imports isTypeOnly={isTypeOnly} />
-        {children}
-      </File>
-    </Parser>
+    <File
+      baseName={baseName}
+      path={resolvedPath}
+      meta={{
+        pluginKey: plugin.key,
+      }}
+    >
+      <Schema.Imports isTypeOnly={isTypeOnly} />
+      {children}
+    </File>
   )
 }
 
 type SchemaImportsProps = {
   isTypeOnly?: boolean
-  extName?: KubbFile.Extname
 }
 
-Schema.Imports = ({ isTypeOnly, extName }: SchemaImportsProps): ReactNode => {
+Schema.Imports = ({ isTypeOnly }: SchemaImportsProps): ReactNode => {
   const { tree } = useSchema()
   const { path: root } = useFile()
 
@@ -118,9 +118,7 @@ Schema.Imports = ({ isTypeOnly, extName }: SchemaImportsProps): ReactNode => {
             return undefined
           }
 
-          return (
-            <File.Import key={i} extName={extName} root={root} name={[item.args.name]} path={item.args.path} isTypeOnly={item.args.isTypeOnly ?? isTypeOnly} />
-          )
+          return <File.Import key={i} root={root} name={[item.args.name]} path={item.args.path} isTypeOnly={isTypeOnly} />
         })
         .filter(Boolean)}
     </>

package/src/generator.tsx

@@ -0,0 +1,125 @@
+import type { PluginFactoryOptions } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
+import type { Operation, SchemaObject } from '@kubb/oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { App, createRoot } from '@kubb/react'
+import type { KubbNode } from '@kubb/react/types'
+import type { OperationGenerator } from './OperationGenerator.ts'
+import type { SchemaGenerator, SchemaGeneratorOptions } from './SchemaGenerator.ts'
+import type { OperationsByMethod } from './types.ts'
+
+type OperationsProps<TOptions extends PluginFactoryOptions> = {
+  instance: Omit<OperationGenerator<TOptions>, 'build'>
+  options: TOptions['resolvedOptions']
+  operations: Array<Operation>
+  operationsByMethod: OperationsByMethod
+}
+
+type OperationProps<TOptions extends PluginFactoryOptions> = {
+  instance: Omit<OperationGenerator<TOptions>, 'build'>
+  options: TOptions['resolvedOptions']
+  operation: Operation
+}
+
+type SchemaProps<TOptions extends PluginFactoryOptions> = {
+  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
+  name: string
+  schema: SchemaObject
+  options: TOptions['resolvedOptions']
+}
+
+export type GeneratorOptions<TOptions extends PluginFactoryOptions> = {
+  name: string
+  operations?: (props: OperationsProps<TOptions>) => Promise<KubbFile.File[]>
+  operation?: (props: OperationProps<TOptions>) => Promise<KubbFile.File[]>
+  schema?: (props: SchemaProps<TOptions>) => Promise<KubbFile.File[]>
+}
+
+export type Generator<TOptions extends PluginFactoryOptions> = GeneratorOptions<TOptions>
+
+export function createGenerator<TOptions extends PluginFactoryOptions>(parseOptions: GeneratorOptions<TOptions>): Generator<TOptions> {
+  return parseOptions
+}
+
+export type ReactGeneratorOptions<TOptions extends PluginFactoryOptions> = {
+  name: string
+  Operations?: (props: OperationsProps<TOptions>) => KubbNode
+  Operation?: (props: OperationProps<TOptions>) => KubbNode
+  Schema?: (props: SchemaProps<TOptions>) => KubbNode
+  /**
+   * Combine all react nodes and only render ones(to string or render)
+   */
+  render?: () => any
+}
+
+export function createReactGenerator<TOptions extends PluginFactoryOptions>(parseOptions: ReactGeneratorOptions<TOptions>): Generator<TOptions> {
+  return {
+    ...parseOptions,
+    async operations({ instance, options, operations, operationsByMethod }) {
+      if (!parseOptions.Operations) {
+        return []
+      }
+
+      const { pluginManager, oas, plugin, mode } = instance.context
+      const root = createRoot({
+        logger: pluginManager.logger,
+      })
+
+      root.render(
+        <App pluginManager={pluginManager} plugin={plugin} mode={mode}>
+          <Oas oas={oas} operations={operations} generator={instance}>
+            <parseOptions.Operations operations={operations} instance={instance} operationsByMethod={operationsByMethod} options={options} />
+          </Oas>
+        </App>,
+      )
+
+      return root.files
+    },
+    async operation({ instance, operation, options }) {
+      if (!parseOptions.Operation) {
+        return []
+      }
+
+      const { pluginManager, oas, plugin, mode } = instance.context
+      const root = createRoot({
+        logger: pluginManager.logger,
+      })
+
+      root.render(
+        <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+          <Oas oas={oas} operations={[operation]} generator={instance}>
+            <Oas.Operation operation={operation}>
+              <parseOptions.Operation operation={operation} options={options} instance={instance} />
+            </Oas.Operation>
+          </Oas>
+        </App>,
+      )
+
+      return root.files
+    },
+    async schema({ instance, schema, name, options }) {
+      if (!parseOptions.Schema) {
+        return []
+      }
+
+      const { pluginManager, oas, plugin, mode } = instance.context
+      const root = createRoot({
+        logger: pluginManager.logger,
+      })
+
+      const tree = instance.parse({ schema, name })
+
+      root.render(
+        <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+          <Oas oas={oas}>
+            <Oas.Schema name={name} value={schema} tree={tree}>
+              <parseOptions.Schema schema={schema} options={options} instance={instance} name={name} />
+            </Oas.Schema>
+          </Oas>
+        </App>,
+      )
+
+      return root.files
+    },
+  }
+}

package/src/hooks/useOperationManager.ts

@@ -57,6 +57,7 @@ export function useOperationManager(): UseOperationManagerResult {
   const getFile: UseOperationManagerResult['getFile'] = (operation, { pluginKey = plugin.key, extName = '.ts' } = {}) => {
     // needed for the `output.group`
     const tag = operation.getTags().at(0)?.name
+    //TODO replace with group
     const name = getName(operation, { type: 'file', pluginKey })
 
     const file = pluginManager.getFile({

package/src/index.ts

@@ -1,5 +1,3 @@
-import { pluginOas } from './plugin.ts'
-
 export type {
   GetOperationGeneratorOptions,
   OperationMethodResult,
@@ -22,10 +20,6 @@ export type {
 } from './SchemaMapper.ts'
 export { isKeyword, schemaKeywords } from './SchemaMapper.ts'
 export type * from './types.ts'
-
-/**
- * @deprecated Use `import { pluginOas } from '@kubb/plugin-oas'` instead
- */
-const definePluginDefault = pluginOas
-
-export default definePluginDefault
+export { createGenerator, createReactGenerator } from './generator.tsx'
+export type { ReactGeneratorOptions } from './generator.tsx'
+export type { Generator, GeneratorOptions } from './generator.tsx'