@kubb/plugin-oas 4.4.0 → 4.5.0

package/src/SchemaGenerator.ts

@@ -1,20 +1,20 @@
 import type { Plugin, PluginFactoryOptions, PluginManager, ResolveNameParams } from '@kubb/core'
 import { BaseGenerator, type FileMetaBase } from '@kubb/core'
-import type { KubbFile } from '@kubb/core/fs'
 import transformers, { pascalCase } from '@kubb/core/transformers'
 import { getUniqueName } from '@kubb/core/utils'
+import type { KubbFile } from '@kubb/fabric-core/types'
 import type { contentType, Oas, OpenAPIV3, SchemaObject } from '@kubb/oas'
 import { isDiscriminator, isNullable, isReference } from '@kubb/oas'
 import type { Fabric } from '@kubb/react-fabric'
 import pLimit from 'p-limit'
 import { isDeepEqual, isNumber, uniqueWith } from 'remeda'
 import type { Generator } from './generators/types.ts'
-import { buildSchema } from './generators/utils.tsx'
 import type { Schema, SchemaKeywordMapper } from './SchemaMapper.ts'
 import { isKeyword, schemaKeywords } from './SchemaMapper.ts'
 import type { OperationSchema, Override, Refs } from './types.ts'
 import { getSchemaFactory } from './utils/getSchemaFactory.ts'
 import { getSchemas } from './utils/getSchemas.ts'
+import { buildSchema } from './utils.tsx'
 
 export type GetSchemaGeneratorOptions<T extends SchemaGenerator<any, any, any>> = T extends SchemaGenerator<infer Options, any, any> ? Options : never
 
@@ -91,14 +91,6 @@ export class SchemaGenerator<
     return uniqueWith(schemas, isDeepEqual)
   }
 
-  deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]> {
-    return SchemaGenerator.deepSearch<T>(tree, keyword)
-  }
-
-  find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
-    return SchemaGenerator.find<T>(tree, keyword)
-  }
-
   static deepSearch<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): Array<SchemaKeywordMapper[T]> {
     const foundItems: SchemaKeywordMapper[T][] = []
 
@@ -145,32 +137,6 @@ export class SchemaGenerator<
     return foundItems
   }
 
-  static findInObject<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
-    let foundItem: SchemaKeywordMapper[T] | undefined
-
-    tree?.forEach((schema) => {
-      if (!foundItem && schema.keyword === keyword) {
-        foundItem = schema as SchemaKeywordMapper[T]
-      }
-
-      if (isKeyword(schema, schemaKeywords.object)) {
-        Object.values(schema.args?.properties || {}).forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = SchemaGenerator.find<T>(entrySchema, keyword)
-          }
-        })
-
-        Object.values(schema.args?.additionalProperties || {}).forEach((entrySchema) => {
-          if (!foundItem) {
-            foundItem = SchemaGenerator.find<T>([entrySchema], keyword)
-          }
-        })
-      }
-    })
-
-    return foundItem
-  }
-
   static find<T extends keyof SchemaKeywordMapper>(tree: Schema[] | undefined, keyword: T): SchemaKeywordMapper[T] | undefined {
     let foundItem: SchemaKeywordMapper[T] | undefined
 
@@ -563,13 +529,17 @@ export class SchemaGenerator<
     if (max !== undefined) {
       if (exclusiveMaximum) {
         baseItems.unshift({ keyword: schemaKeywords.exclusiveMaximum, args: max })
-      } else baseItems.unshift({ keyword: schemaKeywords.max, args: max })
+      } else {
+        baseItems.unshift({ keyword: schemaKeywords.max, args: max })
+      }
     }
 
     if (min !== undefined) {
       if (exclusiveMinimum) {
         baseItems.unshift({ keyword: schemaKeywords.exclusiveMinimum, args: min })
-      } else baseItems.unshift({ keyword: schemaKeywords.min, args: min })
+      } else {
+        baseItems.unshift({ keyword: schemaKeywords.min, args: min })
+      }
     }
 
     if (typeof exclusiveMaximum === 'number') {
@@ -1127,12 +1097,16 @@ export class SchemaGenerator<
                   tree,
                 },
                 {
+                  config: this.context.pluginManager.config,
                   fabric: this.context.fabric,
-                  generator,
-                  instance: this,
-                  options: {
-                    ...this.options,
-                    ...options,
+                  Component: generator.Schema,
+                  generator: this,
+                  plugin: {
+                    ...this.context.plugin,
+                    options: {
+                      ...this.options,
+                      ...options,
+                    },
                   },
                 },
               )
@@ -1141,15 +1115,19 @@ export class SchemaGenerator<
             }
 
             const result = await generator.schema?.({
-              instance: this,
+              config: this.context.pluginManager.config,
+              generator: this,
               schema: {
                 name,
                 value: schemaObject,
                 tree,
               },
-              options: {
-                ...this.options,
-                ...options,
+              plugin: {
+                ...this.context.plugin,
+                options: {
+                  ...this.options,
+                  ...options,
+                },
               },
             })
 

package/src/SchemaMapper.ts

@@ -1,4 +1,5 @@
-import type { KubbFile } from '@kubb/core/fs'
+import type { KubbFile } from '@kubb/fabric-core/types'
+import type { SchemaObject } from '@kubb/oas'
 
 export type SchemaKeywordMapper = {
   object: {
@@ -161,6 +162,7 @@ export type SchemaKeywordBase<T> = {
 export type Schema = { keyword: string } | SchemaKeywordMapper[keyof SchemaKeywordMapper]
 
 export type SchemaTree = {
+  schema: SchemaObject
   parent: Schema | undefined
   current: Schema
   siblings: Schema[]

package/src/generators/createGenerator.ts

@@ -1,5 +1,5 @@
 import type { PluginFactoryOptions } from '@kubb/core'
-import type { KubbFile } from '@kubb/core/fs'
+import type { KubbFile } from '@kubb/fabric-core/types'
 import type { OperationProps, OperationsProps, SchemaProps } from './types.ts'
 
 type UserGenerator<TOptions extends PluginFactoryOptions> = {

package/src/generators/index.ts

@@ -2,4 +2,3 @@ export { createGenerator } from './createGenerator.ts'
 export { createReactGenerator } from './createReactGenerator.ts'
 export { jsonGenerator } from './jsonGenerator.ts'
 export type { Generator } from './types.ts'
-export { buildOperation, buildOperations, buildSchema } from './utils.tsx'

package/src/generators/jsonGenerator.ts

@@ -6,8 +6,8 @@ import { createGenerator } from './createGenerator.ts'
 
 export const jsonGenerator = createGenerator<PluginOas>({
   name: 'plugin-oas',
-  async schema({ schema, instance }) {
-    const { pluginManager, plugin } = instance.context
+  async schema({ schema, generator }) {
+    const { pluginManager, plugin } = generator.context
     const file = pluginManager.getFile({
       name: camelCase(schema.name),
       extname: '.json',
@@ -27,11 +27,11 @@ export const jsonGenerator = createGenerator<PluginOas>({
           },
         ],
         banner: getBanner({
-          oas: instance.context.oas,
+          oas: generator.context.oas,
           output: plugin.options.output,
           config: pluginManager.config,
         }),
-        format: getFooter({ oas: instance.context.oas, output: plugin.options.output }),
+        format: getFooter({ oas: generator.context.oas, output: plugin.options.output }),
       },
     ]
   },

package/src/generators/types.ts

@@ -1,30 +1,29 @@
-import type { PluginFactoryOptions } from '@kubb/core'
+import type { Config, Plugin, PluginFactoryOptions } from '@kubb/core'
 import type { Operation, SchemaObject } from '@kubb/oas'
-import type { OperationGenerator, Schema, SchemaGenerator, SchemaGeneratorOptions } from '@kubb/plugin-oas'
+import type { OperationGenerator } from '../OperationGenerator.ts'
+import type { SchemaGenerator, SchemaGeneratorOptions } from '../SchemaGenerator.ts'
+import type { Schema } from '../SchemaMapper.ts'
 import type { CoreGenerator } from './createGenerator.ts'
 import type { ReactGenerator } from './createReactGenerator.ts'
 
 export type OperationsProps<TOptions extends PluginFactoryOptions> = {
-  /**
-   * @deprecated
-   */
-  instance: Omit<OperationGenerator<TOptions>, 'build'>
-  options: TOptions['resolvedOptions']
+  config: Config
+  generator: Omit<OperationGenerator<TOptions>, 'build'>
+  plugin: Plugin<TOptions>
   operations: Array<Operation>
 }
 
 export type OperationProps<TOptions extends PluginFactoryOptions> = {
-  /**
-   * @deprecated
-   */
-  instance: Omit<OperationGenerator<TOptions>, 'build'>
-  options: TOptions['resolvedOptions']
+  config: Config
+  generator: Omit<OperationGenerator<TOptions>, 'build'>
+  plugin: Plugin<TOptions>
   operation: Operation
 }
 
 export type SchemaProps<TOptions extends PluginFactoryOptions> = {
-  instance: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
-  options: TOptions['resolvedOptions']
+  config: Config
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
+  plugin: Plugin<TOptions>
   schema: {
     name: string
     tree: Array<Schema>

package/src/hooks/index.ts

@@ -1,7 +1,4 @@
 export { useOas } from './useOas.ts'
-export { useOperation } from './useOperation.ts'
-export { useOperationManager } from './useOperationManager.ts'
 export type { SchemaNames } from './useOperationManager.ts'
-export { useOperations } from './useOperations.ts'
-export { useSchema } from './useSchema.ts'
+export { useOperationManager } from './useOperationManager.ts'
 export { useSchemaManager } from './useSchemaManager.ts'

package/src/hooks/useOas.ts

@@ -1,15 +1,9 @@
-import { useContext } from '@kubb/react-fabric'
+import type { Oas } from '@kubb/oas'
 
-import { Oas } from '../components/Oas.tsx'
+import { useApp } from '@kubb/react-fabric'
 
-import type { Oas as OasType } from '@kubb/oas'
+export function useOas(): Oas {
+  const { meta } = useApp<{ oas: Oas }>()
 
-export function useOas(): OasType {
-  const { oas } = useContext(Oas.Context)
-
-  if (!oas) {
-    throw new Error('Oas is not defined')
-  }
-
-  return oas
+  return meta.oas
 }

package/src/hooks/useOperationManager.ts

@@ -1,9 +1,8 @@
 import type { FileMetaBase, Plugin, ResolveNameParams } from '@kubb/core'
-import type { KubbFile } from '@kubb/core/fs'
 import { usePlugin, usePluginManager } from '@kubb/core/hooks'
+import type { KubbFile } from '@kubb/fabric-core/types'
 import type { Operation, Operation as OperationType } from '@kubb/oas'
-import { useContext } from '@kubb/react-fabric'
-import { Oas } from '../components/Oas.tsx'
+import type { OperationGenerator } from '../OperationGenerator.ts'
 import type { OperationSchemas } from '../types.ts'
 
 type FileMeta = FileMetaBase & {
@@ -63,10 +62,9 @@ type UseOperationManagerResult = {
 /**
  * `useOperationManager` will return some helper functions that can be used to get the operation file, get the operation name.
  */
-export function useOperationManager(): UseOperationManagerResult {
+export function useOperationManager(generator: Omit<OperationGenerator, 'build'>): UseOperationManagerResult {
   const plugin = usePlugin()
   const pluginManager = usePluginManager()
-  const { generator } = useContext(Oas.Context)
 
   const getName: UseOperationManagerResult['getName'] = (operation, { prefix = '', suffix = '', pluginKey = plugin.key, type }) => {
     return pluginManager.resolveName({

package/src/hooks/useSchemaManager.ts

@@ -1,6 +1,6 @@
 import type { FileMetaBase, Plugin, ResolveNameParams } from '@kubb/core'
-import type { KubbFile } from '@kubb/core/fs'
 import { usePlugin, usePluginManager } from '@kubb/core/hooks'
+import type { KubbFile } from '@kubb/fabric-core/types'
 import { SchemaGenerator } from '../SchemaGenerator.ts'
 import { type Schema, schemaKeywords } from '../SchemaMapper'
 

package/src/index.ts

@@ -1,4 +1,3 @@
-export * from './generators/index.ts'
 export type { OperationMethodResult } from './OperationGenerator.ts'
 export { OperationGenerator } from './OperationGenerator.ts'
 export { pluginOas, pluginOasName } from './plugin.ts'
@@ -19,3 +18,4 @@ export type {
 } from './SchemaMapper.ts'
 export { isKeyword, schemaKeywords } from './SchemaMapper.ts'
 export type * from './types.ts'
+export { buildOperation, buildOperations, buildSchema } from './utils.tsx'

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { Group, Output, Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { KubbFile } from '@kubb/core/fs'
+import type { KubbFile } from '@kubb/fabric-core/types'
 
 import type { contentType, HttpMethod, Oas, Operation, SchemaObject } from '@kubb/oas'
 import type { Generator } from './generators/types.ts'

package/src/utils/getBanner.ts

@@ -1,7 +1,7 @@
+import path from 'node:path'
 import type { Config, Output } from '@kubb/core'
 import type { Oas } from '@kubb/oas'
 import { isFunction } from 'remeda'
-import path from 'node:path'
 
 type Props<TOas extends Oas> = {
   oas: TOas

package/src/utils/getParams.ts

@@ -1,8 +1,7 @@
-import { isParameterObject } from '@kubb/oas'
-
 import { camelCase, isValidVarName } from '@kubb/core/transformers'
 import type { FunctionParamsAST } from '@kubb/core/utils'
 import type { OasTypes } from '@kubb/oas'
+import { isParameterObject } from '@kubb/oas'
 import type { Params } from '@kubb/react-fabric/types'
 import type { OperationSchema } from '../types.ts'
 /**

package/src/utils/getSchemaFactory.ts

@@ -1,6 +1,5 @@
-import { isOpenApiV3_1Document } from '@kubb/oas'
-
 import type { Oas, OpenAPIV3, OpenAPIV3_1, SchemaObject } from '@kubb/oas'
+import { isOpenApiV3_1Document } from '@kubb/oas'
 
 /**
  * Make it possible to narrow down the schema based on a specific version(3 or 3.1)

package/src/utils/getSchemas.ts

@@ -1,4 +1,4 @@
-import type { Oas, OasTypes, contentType } from '@kubb/oas'
+import type { contentType, Oas, OasTypes } from '@kubb/oas'
 
 type Mode = 'schemas' | 'responses' | 'requestBodies'
 
@@ -8,9 +8,82 @@ type GetSchemasProps = {
   includes?: Mode[]
 }
 
+/**
+ * Collect all schema $ref dependencies recursively.
+ */
+function collectRefs(schema: unknown, refs = new Set<string>()): Set<string> {
+  if (Array.isArray(schema)) {
+    for (const item of schema) {
+      collectRefs(item, refs)
+    }
+    return refs
+  }
+
+  if (schema && typeof schema === 'object') {
+    for (const [key, value] of Object.entries(schema)) {
+      if (key === '$ref' && typeof value === 'string') {
+        const match = value.match(/^#\/components\/schemas\/(.+)$/)
+        if (match) {
+          refs.add(match[1]!)
+        }
+      } else {
+        collectRefs(value, refs)
+      }
+    }
+  }
+
+  return refs
+}
+
+/**
+ * Sort schemas topologically so referenced schemas appear first.
+ */
+function sortSchemas(schemas: Record<string, OasTypes.SchemaObject>): Record<string, OasTypes.SchemaObject> {
+  const deps = new Map<string, string[]>()
+
+  for (const [name, schema] of Object.entries(schemas)) {
+    deps.set(name, Array.from(collectRefs(schema)))
+  }
+
+  const sorted: string[] = []
+  const visited = new Set<string>()
+
+  function visit(name: string, stack = new Set<string>()) {
+    if (visited.has(name)) {
+      return
+    }
+    if (stack.has(name)) {
+      return
+    } // circular refs, ignore
+    stack.add(name)
+    const children = deps.get(name) || []
+    for (const child of children) {
+      if (deps.has(child)) {
+        visit(child, stack)
+      }
+    }
+    stack.delete(name)
+    visited.add(name)
+    sorted.push(name)
+  }
+
+  for (const name of Object.keys(schemas)) {
+    visit(name)
+  }
+
+  const sortedSchemas: Record<string, OasTypes.SchemaObject> = {}
+  for (const name of sorted) {
+    sortedSchemas[name] = schemas[name]!
+  }
+  return sortedSchemas
+}
+
+/**
+ * Collect schemas from OpenAPI components (schemas, responses, requestBodies)
+ * and return them in dependency order.
+ */
 export function getSchemas({ oas, contentType, includes = ['schemas', 'requestBodies', 'responses'] }: GetSchemasProps): Record<string, OasTypes.SchemaObject> {
   const components = oas.getDefinition().components
-
   let schemas: Record<string, OasTypes.SchemaObject> = {}
 
   if (includes.includes('schemas')) {
@@ -20,26 +93,27 @@ export function getSchemas({ oas, contentType, includes = ['schemas', 'requestBo
     }
   }
 
-  const requestBodies = components?.requestBodies || {}
   if (includes.includes('responses')) {
     const responses = components?.responses || {}
-
-    Object.entries(responses).forEach(([name, response]: [string, OasTypes.ResponseObject]) => {
-      if (response.content && !schemas[name]) {
-        const firstContentType = Object.keys(response.content)[0] || 'application/json'
-        schemas[name] = response.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject
+    for (const [name, response] of Object.entries(responses)) {
+      const r = response as OasTypes.ResponseObject
+      if (r.content && !schemas[name]) {
+        const firstContentType = Object.keys(r.content)[0] || 'application/json'
+        schemas[name] = r.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject
       }
-    })
+    }
   }
 
   if (includes.includes('requestBodies')) {
-    Object.entries(requestBodies).forEach(([name, request]: [string, OasTypes.RequestBodyObject]) => {
-      if (request.content && !schemas[name]) {
-        const firstContentType = Object.keys(request.content)[0] || 'application/json'
-        schemas[name] = request.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject
+    const requestBodies = components?.requestBodies || {}
+    for (const [name, request] of Object.entries(requestBodies)) {
+      const r = request as OasTypes.RequestBodyObject
+      if (r.content && !schemas[name]) {
+        const firstContentType = Object.keys(r.content)[0] || 'application/json'
+        schemas[name] = r.content?.[contentType || firstContentType]?.schema as OasTypes.SchemaObject
       }
-    })
+    }
   }
 
-  return schemas
+  return sortSchemas(schemas)
 }

package/src/utils/index.ts

@@ -1,9 +1,8 @@
+export { isOptional } from '@kubb/oas'
+export { getBanner } from './getBanner.ts'
 export { getComments } from './getComments.ts'
+export { getFooter } from './getFooter.ts'
 export { getPathParams } from './getParams.ts'
 export { getSchemaFactory } from './getSchemaFactory.ts'
 export { getSchemas } from './getSchemas.ts'
 export { parseFromConfig } from './parseFromConfig.ts'
-export { getBanner } from './getBanner.ts'
-export { getFooter } from './getFooter.ts'
-
-export { isOptional } from '@kubb/oas'

package/src/utils/parseFromConfig.ts

@@ -1,11 +1,7 @@
 import { resolve } from 'node:path'
-
-import { URLPath } from '@kubb/core/utils'
-
-import { merge, parse } from '@kubb/oas'
-
 import type { Config } from '@kubb/core'
-import { Oas, type OasTypes } from '@kubb/oas'
+import { URLPath } from '@kubb/core/utils'
+import { merge, Oas, type OasTypes, parse } from '@kubb/oas'
 import yaml from '@stoplight/yaml'
 
 export function parseFromConfig(config: Config, oasClass: typeof Oas = Oas): Promise<Oas> {

package/src/utils.tsx

@@ -0,0 +1,101 @@
+import type { Config, Plugin, PluginFactoryOptions } from '@kubb/core'
+import type { Operation, SchemaObject } from '@kubb/oas'
+import { App, createReactFabric, type Fabric } from '@kubb/react-fabric'
+import type { ReactGenerator } from './generators/createReactGenerator.ts'
+import type { OperationGenerator } from './OperationGenerator.ts'
+import type { SchemaGenerator, SchemaGeneratorOptions } from './SchemaGenerator.ts'
+import type { Schema } from './SchemaMapper.ts'
+
+type BuildOperationsOptions<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  fabric: Fabric
+  Component: ReactGenerator<any>['Operations']
+  generator: Omit<OperationGenerator<TOptions>, 'build'>
+  plugin: Plugin<TOptions>
+}
+
+export async function buildOperations<TOptions extends PluginFactoryOptions>(
+  operations: Array<Operation>,
+  { config, fabric, plugin, generator, Component }: BuildOperationsOptions<TOptions>,
+): Promise<void> {
+  if (!Component) {
+    return undefined
+  }
+
+  const { pluginManager, oas, mode } = generator.context
+
+  const fabricChild = createReactFabric()
+  fabricChild.render(() => {
+    return (
+      <App meta={{ pluginManager, plugin, mode, oas }}>
+        <Component config={config} operations={operations} generator={generator} plugin={plugin} />
+      </App>
+    )
+  })
+
+  await fabric.context.fileManager.add(...fabricChild.files)
+}
+
+type BuildOperationOptions<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  fabric: Fabric
+  Component: ReactGenerator<any>['Operation']
+  generator: Omit<OperationGenerator<TOptions>, 'build'>
+  plugin: Plugin<TOptions>
+}
+
+export async function buildOperation<TOptions extends PluginFactoryOptions>(
+  operation: Operation,
+  { config, fabric, plugin, generator, Component }: BuildOperationOptions<TOptions>,
+): Promise<void> {
+  if (!Component) {
+    return undefined
+  }
+
+  const { pluginManager, oas, mode } = generator.context
+
+  const fabricChild = createReactFabric()
+  fabricChild.render(() => {
+    return (
+      <App meta={{ pluginManager, plugin, mode, oas }}>
+        <Component config={config} operation={operation} plugin={plugin} generator={generator} />
+      </App>
+    )
+  })
+
+  await fabric.context.fileManager.add(...fabricChild.files)
+}
+
+type BuildSchemaOptions<TOptions extends PluginFactoryOptions> = {
+  config: Config
+  fabric: Fabric
+  Component: ReactGenerator<any>['Schema']
+  generator: Omit<SchemaGenerator<SchemaGeneratorOptions, TOptions>, 'build'>
+  plugin: Plugin<TOptions>
+}
+
+export async function buildSchema<TOptions extends PluginFactoryOptions>(
+  schema: {
+    name: string
+    tree: Array<Schema>
+    value: SchemaObject
+  },
+  { config, fabric, plugin, Component, generator }: BuildSchemaOptions<TOptions>,
+): Promise<void> {
+  if (!Component) {
+    return undefined
+  }
+
+  const { pluginManager, oas, mode } = generator.context
+
+  const fabricChild = createReactFabric()
+  fabricChild.render(() => {
+    return (
+      <App meta={{ pluginManager, plugin, mode, oas }}>
+        <Component config={config} schema={schema} plugin={plugin} generator={generator} />
+      </App>
+    )
+  })
+
+  await fabric.context.fileManager.add(...fabricChild.files)
+}