@kubb/swagger-ts 2.10.0 → 2.11.1

package/src/OperationGenerator.tsx

@@ -2,9 +2,8 @@ import { createRoot } from '@kubb/react'
 import { OperationGenerator as Generator } from '@kubb/swagger'
 import { Oas } from '@kubb/swagger/components'
 
-import { Mutation } from './components/Mutation.tsx'
 import { OasType } from './components/OasType.tsx'
-import { Query } from './components/Query.tsx'
+import { OperationSchema } from './components/OperationSchema.tsx'
 
 import type { AppContextProps } from '@kubb/react'
 import type { OperationMethodResult } from '@kubb/swagger'
@@ -18,7 +17,7 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
 
     root.render(
-      <Oas oas={oas} operations={operations} getSchemas={(...props) => this.getSchemas(...props)}>
+      <Oas oas={oas} operations={operations} getOperationSchemas={(...props) => this.getSchemas(...props)}>
         {plugin.options.oasType && <OasType.File name="oas" typeName="Oas" />}
       </Oas>,
       { meta: { pluginManager, plugin } },
@@ -27,14 +26,17 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     return root.files
   }
 
-  async get(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    const { oas, pluginManager, plugin, mode = 'directory' } = this.context
+  async operation(
+    operation: Operation,
+    options: PluginOptions['resolvedOptions'],
+  ): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode } = this.context
 
     const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
     root.render(
-      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
+      <Oas oas={oas} operations={[operation]} getOperationSchemas={(...props) => this.getSchemas(...props)}>
         <Oas.Operation operation={operation}>
-          <Query.File mode={mode} />
+          <OperationSchema.File mode={mode} />
         </Oas.Operation>
       </Oas>,
       { meta: { pluginManager, plugin: { ...plugin, options } } },
@@ -43,29 +45,21 @@ export class OperationGenerator extends Generator<PluginOptions['resolvedOptions
     return root.files
   }
 
-  async post(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    const { oas, pluginManager, plugin, mode = 'directory' } = this.context
-
-    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
-    root.render(
-      <Oas oas={oas} operations={[operation]} getSchemas={(...props) => this.getSchemas(...props)}>
-        <Oas.Operation operation={operation}>
-          <Mutation.File mode={mode} />
-        </Oas.Operation>
-      </Oas>,
-      { meta: { pluginManager, plugin: { ...plugin, options } } },
-    )
+  async get(): OperationMethodResult<FileMeta> {
+    return null
+  }
 
-    return root.files
+  async post(): OperationMethodResult<FileMeta> {
+    return null
   }
 
-  async put(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, options)
+  async put(): OperationMethodResult<FileMeta> {
+    return null
   }
-  async patch(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, options)
+  async patch(): OperationMethodResult<FileMeta> {
+    return null
   }
-  async delete(operation: Operation, options: PluginOptions['resolvedOptions']): OperationMethodResult<FileMeta> {
-    return this.post(operation, options)
+  async delete(): OperationMethodResult<FileMeta> {
+    return null
   }
 }

package/src/SchemaGenerator.tsx

@@ -0,0 +1,63 @@
+import { createRoot } from '@kubb/react'
+import { SchemaGenerator as Generator } from '@kubb/swagger'
+import { Oas, Schema } from '@kubb/swagger/components'
+import { pluginKey as swaggerTypeScriptPluginKey } from '@kubb/swagger-ts'
+
+import { pluginKey } from './plugin.ts'
+import { typeParser } from './typeParser.ts'
+
+import type { AppContextProps } from '@kubb/react'
+import type { Schema as SchemaType, SchemaGeneratorBuildOptions, SchemaMethodResult } from '@kubb/swagger'
+import type { SchemaObject } from '@kubb/swagger/oas'
+import type { FileMeta, PluginOptions } from './types.ts'
+
+export class SchemaGenerator extends Generator<PluginOptions['resolvedOptions'], PluginOptions> {
+  async schema(name: string, object: SchemaObject): SchemaMethodResult<FileMeta> {
+    const { oas, pluginManager, mode, plugin, output } = this.context
+
+    const root = createRoot<AppContextProps<PluginOptions['appMeta']>>({ logger: pluginManager.logger })
+
+    root.render(
+      <Oas oas={oas}>
+        <Oas.Schema generator={this} name={name} object={object}>
+          <Schema.File isTypeOnly output={output} mode={mode} />
+        </Oas.Schema>
+      </Oas>,
+      { meta: { pluginManager, plugin } },
+    )
+
+    return root.files
+  }
+  // TODO convert to a react component called `Schema.Parser` with props parser as part of the SchemaContext
+  getSource(name: string, schemas: SchemaType[], {
+    keysToOmit,
+    description,
+  }: SchemaGeneratorBuildOptions = {}): string[] {
+    const texts: string[] = []
+
+    const resolvedName = this.context.pluginManager.resolveName({ name, pluginKey, type: 'function' })
+    const resvoledTypeName = this.context.pluginManager.resolveName({ name, pluginKey: swaggerTypeScriptPluginKey, type: 'type' })
+
+    const typeOutput = typeParser(schemas, {
+      name: resolvedName,
+      typeName: resvoledTypeName,
+      description,
+      enumType: this.options.enumType || 'asConst',
+      optionalType: this.options.optionalType,
+      keysToOmit,
+    })
+
+    texts.push(typeOutput)
+
+    return texts
+  }
+  /**
+   * @deprecated only used for testing
+   */
+
+  buildSource(name: string, schema: SchemaObject, options: SchemaGeneratorBuildOptions = {}): string[] {
+    const schemas = this.buildSchemas(schema, name)
+
+    return this.getSource(name, schemas, options)
+  }
+}

package/src/components/OasType.tsx

@@ -1,5 +1,5 @@
 import { Editor, File, Type, usePlugin } from '@kubb/react'
-import { useFile } from '@kubb/react'
+import { useGetFile } from '@kubb/react'
 import { useOas } from '@kubb/swagger/hooks'
 
 import type { OasTypes } from '@kubb/swagger/oas'
@@ -63,7 +63,7 @@ type FileProps = {
 
 OasType.File = function({ name, typeName, templates = defaultTemplates }: FileProps): ReactNode {
   const { key: pluginKey } = usePlugin<PluginOptions>()
-  const file = useFile({ name, extName: '.ts', pluginKey })
+  const file = useGetFile({ name, extName: '.ts', pluginKey })
 
   const Template = templates.default
 

package/src/components/{Query.tsx → OperationSchema.tsx}

@@ -1,21 +1,23 @@
+/* eslint-disable no-empty-pattern */
+/* eslint-disable @typescript-eslint/ban-types */
 import transformers from '@kubb/core/transformers'
 import { print } from '@kubb/parser'
 import * as factory from '@kubb/parser/factory'
 import { Editor, File, usePlugin, usePluginManager } from '@kubb/react'
-import { useOas, useOperation, useOperationFile, useOperationName, useSchemas } from '@kubb/swagger/hooks'
+import { Oas, Schema } from '@kubb/swagger/components'
+import { useGetOperationFile, useOas, useOperation, useOperationName, useOperationSchemas } from '@kubb/swagger/hooks'
 
-import { TypeBuilder } from '../TypeBuilder.ts'
+import { SchemaGenerator } from '../SchemaGenerator.tsx'
 
 import type { KubbFile } from '@kubb/core'
 import type { ts } from '@kubb/parser'
+import type { OperationSchema as OperationSchemaType } from '@kubb/swagger'
 import type { OperationSchemas } from '@kubb/swagger'
 import type { Operation } from '@kubb/swagger/oas'
 import type { ReactNode } from 'react'
 import type { FileMeta, PluginOptions } from '../types.ts'
 
-type Props = {
-  builder: TypeBuilder
-}
+type Props = {}
 
 function printCombinedSchema(name: string, operation: Operation, schemas: OperationSchemas): string {
   const properties: Record<string, ts.TypeNode> = {
@@ -87,40 +89,49 @@ function printCombinedSchema(name: string, operation: Operation, schemas: Operat
   return print(namespaceNode)
 }
 
-export function Query({
-  builder,
-}: Props): ReactNode {
-  const { source } = builder.build()
-
+export function OperationSchema({}: Props): ReactNode {
   return (
     <>
-      {source}
     </>
   )
 }
 
 type FileProps = {
-  mode: KubbFile.Mode
+  mode: KubbFile.Mode | undefined
 }
 
-Query.File = function({ mode }: FileProps): ReactNode {
+OperationSchema.File = function({ mode = 'directory' }: FileProps): ReactNode {
   const plugin = usePlugin<PluginOptions>()
 
-  const schemas = useSchemas()
   const pluginManager = usePluginManager()
   const oas = useOas()
-  const file = useOperationFile()
+  const schemas = useOperationSchemas()
+  const file = useGetOperationFile()
   const factoryName = useOperationName({ type: 'type' })
   const operation = useOperation()
 
-  const builder = new TypeBuilder(plugin.options, { oas, plugin, pluginManager })
-    .add(schemas.pathParams)
-    .add(schemas.queryParams)
-    .add(schemas.headerParams)
-    .add(schemas.response)
-    .add(schemas.statusCodes)
-
-  const { source, imports } = builder.build()
+  const generator = new SchemaGenerator(plugin.options, { oas, plugin, pluginManager })
+
+  const items = [
+    schemas.pathParams,
+    schemas.queryParams,
+    schemas.headerParams,
+    schemas.statusCodes,
+    schemas.request,
+    schemas.response,
+  ].flat().filter(Boolean)
+
+  const mapItem = ({ name, schema: object, ...options }: OperationSchemaType, i: number) => {
+    return (
+      <Oas.Schema key={i} generator={generator} name={name} object={object}>
+        {mode === 'directory'
+          && <Schema.Imports isTypeOnly />}
+        <File.Source>
+          <Schema.Source options={options} />
+        </File.Source>
+      </Oas.Schema>
+    )
+  }
 
   return (
     <Editor language="typescript">
@@ -129,11 +140,9 @@ Query.File = function({ mode }: FileProps): ReactNode {
         path={file.path}
         meta={file.meta}
       >
-        {mode === 'directory' && imports.map((item, index) => {
-          return <File.Import key={index} root={file.path} {...item} />
-        })}
+        {items.map(mapItem)}
+
         <File.Source>
-          {source}
           {printCombinedSchema(factoryName, operation, schemas)}
         </File.Source>
       </File>

package/src/components/__snapshots__/Schema/pets.ts

@@ -0,0 +1,27 @@
+/**
+ * @description Null response
+ */
+export type CreatePets201 = any
+
+/**
+ * @description unexpected error
+ */
+export type CreatePetsError = Error
+
+export type CreatePetsMutationRequest = {
+  /**
+   * @type string
+   */
+  name: string
+  /**
+   * @type string
+   */
+  tag: string
+}
+
+export type CreatePetsMutationResponse = any
+
+export type CreatePetsMutation = {
+  Response: CreatePetsMutationResponse
+  Request: CreatePetsMutationRequest
+}

package/src/components/__snapshots__/Schema/showPetById.ts

@@ -0,0 +1,32 @@
+export type ShowPetByIdPathParams = {
+  /**
+   * @description The id of the pet to retrieve
+   * @type string
+   */
+  petId: string
+  /**
+   * @description The id of the pet to retrieve
+   * @type string
+   */
+  testId: string
+}
+
+/**
+ * @description Expected response to a valid request
+ */
+export type ShowPetById200 = Pet
+
+/**
+ * @description unexpected error
+ */
+export type ShowPetByIdError = Error
+
+/**
+ * @description Expected response to a valid request
+ */
+export type ShowPetByIdQueryResponse = Pet
+
+export type ShowPetByIdQuery = {
+  Response: ShowPetByIdQueryResponse
+  PathParams: ShowPetByIdPathParams
+}

package/src/components/index.ts

@@ -1,3 +1,2 @@
-export { Mutation } from './Mutation.tsx'
 export { OasType } from './OasType.tsx'
-export { Query } from './Query.tsx'
+export { OperationSchema } from './OperationSchema.tsx'

package/src/plugin.ts

@@ -6,11 +6,10 @@ import { renderTemplate } from '@kubb/core/utils'
 import { pluginName as swaggerPluginName } from '@kubb/swagger'
 
 import { OperationGenerator } from './OperationGenerator.tsx'
-import { TypeBuilder } from './TypeBuilder.ts'
+import { SchemaGenerator } from './SchemaGenerator.tsx'
 
-import type { KubbFile, Plugin } from '@kubb/core'
+import type { Plugin } from '@kubb/core'
 import type { PluginOptions as SwaggerPluginOptions } from '@kubb/swagger'
-import type { OasTypes } from '@kubb/swagger/oas'
 import type { PluginOptions } from './types.ts'
 export const pluginName = 'swagger-ts' satisfies PluginOptions['name']
 export const pluginKey: PluginOptions['key'] = [pluginName] satisfies PluginOptions['key']
@@ -37,11 +36,11 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
     options: {
       transformers,
       dateType,
-      enumType,
-      enumSuffix,
       optionalType,
       oasType,
-      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
+      enumType,
+      enumSuffix,
+      // keep the used enumnames between SchemaGenerator and OperationGenerator per plugin(pluginKey)
       usedEnumNames: {},
       unknownType,
     },
@@ -86,60 +85,24 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       const [swaggerPlugin]: [Plugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [swaggerPluginName])
 
       const oas = await swaggerPlugin.api.getOas()
-
-      const schemas = await swaggerPlugin.api.getSchemas()
       const root = path.resolve(this.config.root, this.config.output.path)
       const mode = FileManager.getMode(path.resolve(root, output.path))
-      const builder = new TypeBuilder(this.plugin.options, { oas, plugin: this.plugin, pluginManager: this.pluginManager })
 
-      builder.add(
-        Object.entries(schemas).map(([name, schema]: [string, OasTypes.SchemaObject]) => ({ name, schema })),
+      const schemaGenerator = new SchemaGenerator(
+        this.plugin.options,
+        {
+          oas,
+          pluginManager: this.pluginManager,
+          plugin: this.plugin,
+          contentType: swaggerPlugin.api.contentType,
+          include: undefined,
+          mode,
+          output: output.path,
+        },
       )
 
-      if (mode === 'directory') {
-        const mapFolderSchema = async ([name]: [string, OasTypes.SchemaObject]) => {
-          const baseName = `${this.resolveName({ name, pluginKey: this.plugin.key, type: 'file' })}.ts` as const
-          const resolvedPath = this.resolvePath({ baseName, pluginKey: this.plugin.key })
-          const { source, imports } = builder.build(name)
-
-          if (!resolvedPath) {
-            return null
-          }
-
-          return this.addFile({
-            path: resolvedPath,
-            baseName,
-            source,
-            imports: imports.map(item => ({ ...item, root: resolvedPath })),
-            meta: {
-              pluginKey: this.plugin.key,
-            },
-          })
-        }
-
-        const promises = Object.entries(schemas).map(mapFolderSchema)
-
-        await Promise.all(promises)
-      }
-
-      if (mode === 'file') {
-        const resolvedPath = this.resolvePath({ baseName: '', pluginKey: this.plugin.key })
-        const { source } = builder.build()
-
-        if (!resolvedPath) {
-          return
-        }
-
-        await this.addFile({
-          path: resolvedPath,
-          baseName: output.path as KubbFile.BaseName,
-          source,
-          imports: [],
-          meta: {
-            pluginKey: this.plugin.key,
-          },
-        })
-      }
+      const schemaFiles = await schemaGenerator.build()
+      await this.addFile(...schemaFiles)
 
       const operationGenerator = new OperationGenerator(
         this.plugin.options,
@@ -155,8 +118,8 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
         },
       )
 
-      const files = await operationGenerator.build()
-      await this.addFile(...files)
+      const operationFiles = await operationGenerator.build()
+      await this.addFile(...operationFiles)
     },
     async buildEnd() {
       if (this.config.output.write === false) {