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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-oas",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.3",
   "description": "Generator swagger",
   "keywords": [
     "typescript",
@@ -68,10 +68,10 @@
   "dependencies": {
     "@stoplight/yaml": "^4.3.0",
     "remeda": "^2.11.0",
-    "@kubb/core": "3.0.0-alpha.1",
-    "@kubb/fs": "3.0.0-alpha.1",
-    "@kubb/oas": "3.0.0-alpha.1",
-    "@kubb/react": "3.0.0-alpha.1"
+    "@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"
   },
   "devDependencies": {
     "@types/react": "^18.3.4",
@@ -79,12 +79,12 @@
     "react": "^18.3.1",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
-    "@kubb/config-biome": "3.0.0-alpha.1",
-    "@kubb/config-ts": "3.0.0-alpha.1",
-    "@kubb/config-tsup": "3.0.0-alpha.1"
+    "@kubb/config-biome": "3.0.0-alpha.3",
+    "@kubb/config-ts": "3.0.0-alpha.3",
+    "@kubb/config-tsup": "3.0.0-alpha.3"
   },
   "peerDependencies": {
-    "@kubb/react": "3.0.0-alpha.1"
+    "@kubb/react": "3.0.0-alpha.3"
   },
   "engines": {
     "node": ">=20"

package/src/OperationGenerator.ts

@@ -7,6 +7,7 @@ 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 { 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
 
@@ -26,7 +27,7 @@ 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,
@@ -65,6 +66,7 @@ export abstract class OperationGenerator<
       })?.options || {}
     )
   }
+
   /**
    *
    * @deprecated
@@ -93,6 +95,7 @@ export abstract class OperationGenerator<
 
     return matched
   }
+
   /**
    *
    * @deprecated
@@ -124,7 +127,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 +226,7 @@ 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
-  }
-
-  async build(): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...parsers: Array<Parser<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas } = this.context
 
     const paths = oas.getPaths()
@@ -239,7 +235,7 @@ export abstract class OperationGenerator<
 
       methods.forEach((method) => {
         const operation = oas.operation(path, method)
-        if (operation && this.#methods[method]) {
+        if (operation) {
           const isExcluded = this.#isExcluded(operation, method)
           const isIncluded = this.context.include ? this.#isIncluded(operation, method) : true
 
@@ -267,21 +263,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)
         }
+
+        parsers?.forEach((parser) => {
+          const promise = parser.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 +309,19 @@ export abstract class OperationGenerator<
 
     promises.push(this.all(operations.flat().filter(Boolean), this.operationsByMethod))
 
+    parsers?.forEach((parser) => {
+      const promise = parser.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 +332,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

@@ -14,6 +14,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 { 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
 
@@ -63,7 +64,7 @@ type SchemaProps = {
   parentName?: string
 }
 
-export abstract class SchemaGenerator<
+export class SchemaGenerator<
   TOptions extends SchemaGeneratorOptions = SchemaGeneratorOptions,
   TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions,
   TFileMeta extends FileMetaBase = FileMetaBase,
@@ -820,7 +821,7 @@ export abstract class SchemaGenerator<
     return [{ keyword: unknownReturn }]
   }
 
-  async build(): Promise<Array<KubbFile.File<TFileMeta>>> {
+  async build(...parsers: Array<Parser<Extract<TOptions, PluginFactoryOptions>>>): Promise<Array<KubbFile.File<TFileMeta>>> {
     const { oas, contentType, include } = this.context
 
     const schemas = getSchemas({ oas, contentType, includes: include })
@@ -836,17 +837,35 @@ export abstract class SchemaGenerator<
         acc.push(promiseOperation)
       }
 
+      parsers?.forEach((parser) => {
+        const promise = parser.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/components/Oas.tsx

@@ -10,14 +10,20 @@ 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/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 { createParser, createReactParser } from './parser.tsx'
+export type { ParserReactOptions } from './parser.tsx'
+export type { Parser, ParserOptions } from './parser.tsx'

package/src/parser.tsx

@@ -0,0 +1,120 @@
+import type { PluginFactoryOptions } from '@kubb/core'
+import type { Operation, SchemaObject } from '@kubb/oas'
+import { App, createRoot, type KubbNode } from '@kubb/react'
+import type * as KubbFile from '@kubb/fs/types'
+import type { OperationsByMethod } from './types.ts'
+import { Oas } from '@kubb/plugin-oas/components'
+import type { OperationGenerator } from './OperationGenerator.ts'
+import type { SchemaGenerator, SchemaGeneratorOptions } from './SchemaGenerator.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 ParserOptions<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 Parser<TOptions extends PluginFactoryOptions> = ParserOptions<TOptions>
+
+export function createParser<TOptions extends PluginFactoryOptions>(parseOptions: ParserOptions<TOptions>): Parser<TOptions> {
+  return parseOptions
+}
+
+export type ParserReactOptions<TOptions extends PluginFactoryOptions> = {
+  name: string
+  Operations?: (props: OperationsProps<TOptions>) => KubbNode
+  Operation?: (props: OperationProps<TOptions>) => KubbNode
+  Schema?: (props: SchemaProps<TOptions>) => KubbNode
+}
+
+export function createReactParser<TOptions extends PluginFactoryOptions>(parseOptions: ParserReactOptions<TOptions>): Parser<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/plugin.ts

@@ -46,8 +46,7 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
   return {
     name: pluginOasName,
     options,
-
-    api() {
+    context() {
       const { config, logger } = this
 
       return {
@@ -78,13 +77,6 @@ export const pluginOas = createPlugin<PluginOas>((options) => {
     resolveName(name, type) {
       return camelCase(name, { isFile: type === 'file' })
     },
-    async writeFile(path, source) {
-      if (!path.endsWith('.json') || !source) {
-        return
-      }
-
-      return this.fileManager.write(path, source, { sanity: false })
-    },
     async buildStart() {
       if (!output) {
         return

package/dist/OperationGenerator-CeM_9pxW.d.cts

@@ -1,60 +0,0 @@
-import { FileMetaBase, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
-import * as KubbFile from '@kubb/fs/types';
-import { Operation, Oas, contentType } from '@kubb/oas';
-import { g as OperationsByMethod, f as OperationSchemas, E as Exclude, I as Include, b as Override } from './types-Dte3MA6H.cjs';
-
-type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never;
-type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
-    oas: Oas;
-    exclude: Array<Exclude> | undefined;
-    include: Array<Include> | undefined;
-    override: Array<Override<TOptions>> | undefined;
-    contentType: contentType | undefined;
-    pluginManager: PluginManager;
-    /**
-     * Current plugin
-     */
-    plugin: Plugin<TPluginOptions>;
-    mode: KubbFile.Mode;
-};
-declare abstract class OperationGenerator<TOptions = unknown, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
-    #private;
-    get operationsByMethod(): OperationsByMethod;
-    set operationsByMethod(paths: OperationsByMethod);
-    getSchemas(operation: Operation, { forStatusCode, resolveName }?: {
-        forStatusCode?: string | number;
-        resolveName?: (name: string) => string;
-    }): OperationSchemas;
-    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
-    /**
-     * Operation
-     */
-    operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * GET
-     */
-    get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * POST
-     */
-    post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PATCH
-     */
-    patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PUT
-     */
-    put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * DELETE
-     */
-    delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * Combination of GET, POST, PATCH, PUT, DELETE
-     */
-    all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
-}
-
-export { type GetOperationGeneratorOptions as G, type OperationMethodResult as O, OperationGenerator as a };

package/dist/OperationGenerator-DhUhvRJE.d.ts

@@ -1,60 +0,0 @@
-import { FileMetaBase, PluginFactoryOptions, Generator, PluginManager, Plugin } from '@kubb/core';
-import * as KubbFile from '@kubb/fs/types';
-import { Operation, Oas, contentType } from '@kubb/oas';
-import { g as OperationsByMethod, f as OperationSchemas, E as Exclude, I as Include, b as Override } from './types-Dte3MA6H.js';
-
-type GetOperationGeneratorOptions<T extends OperationGenerator<any, any, any>> = T extends OperationGenerator<infer Options, any, any> ? Options : never;
-type OperationMethodResult<TFileMeta extends FileMetaBase> = Promise<KubbFile.File<TFileMeta> | Array<KubbFile.File<TFileMeta>> | null>;
-type Context<TOptions, TPluginOptions extends PluginFactoryOptions> = {
-    oas: Oas;
-    exclude: Array<Exclude> | undefined;
-    include: Array<Include> | undefined;
-    override: Array<Override<TOptions>> | undefined;
-    contentType: contentType | undefined;
-    pluginManager: PluginManager;
-    /**
-     * Current plugin
-     */
-    plugin: Plugin<TPluginOptions>;
-    mode: KubbFile.Mode;
-};
-declare abstract class OperationGenerator<TOptions = unknown, TPluginOptions extends PluginFactoryOptions = PluginFactoryOptions, TFileMeta extends FileMetaBase = FileMetaBase> extends Generator<TOptions, Context<TOptions, TPluginOptions>> {
-    #private;
-    get operationsByMethod(): OperationsByMethod;
-    set operationsByMethod(paths: OperationsByMethod);
-    getSchemas(operation: Operation, { forStatusCode, resolveName }?: {
-        forStatusCode?: string | number;
-        resolveName?: (name: string) => string;
-    }): OperationSchemas;
-    build(): Promise<Array<KubbFile.File<TFileMeta>>>;
-    /**
-     * Operation
-     */
-    operation(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * GET
-     */
-    get(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * POST
-     */
-    post(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PATCH
-     */
-    patch(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * PUT
-     */
-    put(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * DELETE
-     */
-    delete(operation: Operation, options: TOptions): OperationMethodResult<TFileMeta>;
-    /**
-     * Combination of GET, POST, PATCH, PUT, DELETE
-     */
-    all(operations: Operation[], paths: OperationsByMethod): OperationMethodResult<TFileMeta>;
-}
-
-export { type GetOperationGeneratorOptions as G, type OperationMethodResult as O, OperationGenerator as a };