@kubb/swagger-ts 2.0.0-beta.2 → 2.0.0-beta.4

package/src/components/Query.tsx

@@ -0,0 +1,137 @@
+import transformers from '@kubb/core/transformers'
+import { print } from '@kubb/parser'
+import * as factory from '@kubb/parser/factory'
+import { File, usePlugin, usePluginManager } from '@kubb/react'
+import { useOas, useOperation, useOperationFile, useOperationName, useSchemas } from '@kubb/swagger/hooks'
+
+import { TypeBuilder } from '../TypeBuilder.ts'
+
+import type { ts } from '@kubb/parser'
+import type { Operation, OperationSchemas } from '@kubb/swagger'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginOptions } from '../types.ts'
+import type { KubbFile } from '@kubb/core'
+
+type Props = {
+  builder: TypeBuilder
+}
+
+function printCombinedSchema(name: string, operation: Operation, schemas: OperationSchemas): string {
+  const properties: Record<string, ts.TypeNode> = {
+    'response': factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.response.name),
+      undefined,
+    ),
+  }
+
+  if (schemas.request) {
+    properties['request'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.request.name),
+      undefined,
+    )
+  }
+
+  if (schemas.pathParams) {
+    properties['pathParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.pathParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.queryParams) {
+    properties['queryParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.queryParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.headerParams) {
+    properties['headerParams'] = factory.createTypeReferenceNode(
+      factory.createIdentifier(schemas.headerParams.name),
+      undefined,
+    )
+  }
+
+  if (schemas.errors) {
+    properties['errors'] = factory.createUnionDeclaration({
+      nodes: schemas.errors.map(error => {
+        return factory.createTypeReferenceNode(
+          factory.createIdentifier(error.name),
+          undefined,
+        )
+      }),
+    })!
+  }
+
+  const namespaceNode = factory.createNamespaceDeclaration({
+    name: operation.method === 'get' ? `${name}Query` : `${name}Mutation`,
+    statements: Object.keys(properties).map(key => {
+      const type = properties[key]
+      if (!type) {
+        return undefined
+      }
+      return factory.createTypeAliasDeclaration({
+        modifiers: [factory.modifiers.export],
+        name: transformers.pascalCase(key),
+        type,
+      })
+    }).filter(Boolean),
+  })
+
+  return print(namespaceNode)
+}
+
+export function Query({
+  builder,
+}: Props): ReactNode {
+  const { source } = builder.build()
+
+  return (
+    <>
+      {source}
+    </>
+  )
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+type FileProps = {
+  mode: KubbFile.Mode
+}
+
+Query.File = function({ mode }: FileProps): ReactNode {
+  const { options } = usePlugin<PluginOptions>()
+
+  const schemas = useSchemas()
+  const pluginManager = usePluginManager()
+  const oas = useOas()
+  const file = useOperationFile()
+  const factoryName = useOperationName({ type: 'type' })
+  const operation = useOperation()
+
+  const builder = new TypeBuilder(options, { oas, pluginManager })
+    .add(schemas.pathParams)
+    .add(schemas.queryParams)
+    .add(schemas.headerParams)
+    .add(schemas.response)
+    .add(schemas.errors)
+
+  const { source, imports } = builder.build()
+
+  return (
+    <>
+      <File<FileMeta>
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+      >
+        {mode === 'directory' && imports.map((item, index) => {
+          return <File.Import key={index} root={file.path} {...item} />
+        })}
+        <File.Source>
+          {source}
+          {printCombinedSchema(factoryName, operation, schemas)}
+        </File.Source>
+      </File>
+    </>
+  )
+}

package/src/components/index.ts

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

package/src/plugin.ts

@@ -1,18 +1,16 @@
 import path from 'node:path'
 
 import { createPlugin, FileManager, PluginManager } from '@kubb/core'
-import { getRelativePath, renderTemplate } from '@kubb/core/utils'
+import { camelCase, pascalCase } from '@kubb/core/transformers'
+import { renderTemplate } from '@kubb/core/utils'
 import { pluginName as swaggerPluginName } from '@kubb/swagger'
 
-import { camelCase, camelCaseTransformMerge, pascalCase, pascalCaseTransformMerge } from 'change-case'
-
-import { TypeBuilder } from './builders/index.ts'
-import { OperationGenerator } from './generators/index.ts'
+import { OperationGenerator } from './OperationGenerator.tsx'
+import { TypeBuilder } from './TypeBuilder.ts'
 
 import type { KubbFile, KubbPlugin } from '@kubb/core'
 import type { OasTypes, PluginOptions as SwaggerPluginOptions } from '@kubb/swagger'
 import type { PluginOptions } from './types.ts'
-
 export const pluginName = 'swagger-ts' satisfies PluginOptions['name']
 export const pluginKey: PluginOptions['key'] = [pluginName] satisfies PluginOptions['key']
 
@@ -33,7 +31,14 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
 
   return {
     name: pluginName,
-    options,
+    options: {
+      transformers,
+      dateType,
+      enumType,
+      optionalType,
+      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
+      usedEnumNames: {},
+    },
     pre: [swaggerPluginName],
     resolvePath(baseName, directory, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
@@ -48,7 +53,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       }
 
       if (options?.tag && group?.type === 'tag') {
-        const tag = camelCase(options.tag, { delimiter: '', transform: camelCaseTransformMerge })
+        const tag = camelCase(options.tag)
 
         return path.resolve(root, renderTemplate(template, { tag }), baseName)
       }
@@ -56,7 +61,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       return path.resolve(root, output, baseName)
     },
     resolveName(name, type) {
-      const resolvedName = pascalCase(name, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge })
+      const resolvedName = pascalCase(name)
 
       if (type) {
         return transformers?.name?.(resolvedName, type) || resolvedName
@@ -79,39 +84,17 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       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))
-      // keep the used enumnames between TypeBuilder and OperationGenerator per plugin(pluginKey)
-      const usedEnumNames = {}
-
-      if (mode === 'directory') {
-        const builder = await new TypeBuilder({
-          usedEnumNames,
-          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
-          fileResolver: (name) => {
-            const resolvedTypeId = this.resolvePath({
-              baseName: `${name}.ts`,
-              pluginKey: this.plugin.key,
-            })
-
-            const root = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key })
+      const builder = new TypeBuilder(this.plugin.options, { oas, pluginManager: this.pluginManager })
 
-            return getRelativePath(root, resolvedTypeId)
-          },
-          withJSDocs: true,
-          enumType,
-          dateType,
-          optionalType,
-          oas,
-        }).configure()
-        Object.entries(schemas).forEach(([name, schema]: [string, OasTypes.SchemaObject]) => {
-          // generate and pass through new code back to the core so it can be write to that file
-          return builder.add({
-            schema,
-            name,
-          })
-        })
+      builder.add(
+        Object.entries(schemas).map(([name, schema]: [string, OasTypes.SchemaObject]) => ({ name, schema })),
+      )
 
+      if (mode === 'directory') {
         const mapFolderSchema = async ([name]: [string, OasTypes.SchemaObject]) => {
-          const resolvedPath = this.resolvePath({ baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`, pluginKey: this.plugin.key })
+          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
@@ -119,8 +102,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
 
           return this.addFile({
             path: resolvedPath,
-            baseName: `${this.resolveName({ name, pluginKey: this.plugin.key })}.ts`,
-            source: builder.print(name),
+            baseName,
+            source,
+            imports: imports.map(item => ({ ...item, root: resolvedPath })),
             meta: {
               pluginKey: this.plugin.key,
             },
@@ -133,25 +117,9 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       }
 
       if (mode === 'file') {
-        // outside the loop because we need to add files to just one instance to have the correct sorting, see refsSorter
-        const builder = new TypeBuilder({
-          usedEnumNames,
-          resolveName: (params) => this.resolveName({ pluginKey: this.plugin.key, ...params }),
-          withJSDocs: true,
-          enumType,
-          dateType,
-          optionalType,
-          oas,
-        }).configure()
-        Object.entries(schemas).forEach(([name, schema]: [string, OasTypes.SchemaObject]) => {
-          // generate and pass through new code back to the core so it can be write to that file
-          return builder.add({
-            schema,
-            name,
-          })
-        })
-
         const resolvedPath = this.resolvePath({ baseName: '', pluginKey: this.plugin.key })
+        const { source } = builder.build()
+
         if (!resolvedPath) {
           return
         }
@@ -159,22 +127,16 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
         await this.addFile({
           path: resolvedPath,
           baseName: output as KubbFile.BaseName,
-          source: builder.print(),
+          source,
+          imports: [],
           meta: {
             pluginKey: this.plugin.key,
           },
-          validate: false,
         })
       }
 
       const operationGenerator = new OperationGenerator(
-        {
-          mode,
-          enumType,
-          dateType,
-          optionalType,
-          usedEnumNames,
-        },
+        this.plugin.options,
         {
           oas,
           pluginManager: this.pluginManager,
@@ -183,6 +145,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
           exclude,
           include,
           override,
+          mode,
         },
       )
 

package/src/types.ts

@@ -1,5 +1,5 @@
 import type { KubbPlugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 
 export type Options = {
   /**
@@ -67,13 +67,23 @@ export type Options = {
   }
 }
 
+type ResolvedOptions = {
+  enumType: NonNullable<Options['enumType']>
+  dateType: NonNullable<Options['dateType']>
+  optionalType: NonNullable<Options['optionalType']>
+  transformers: NonNullable<Options['transformers']>
+  usedEnumNames: Record<string, number>
+}
+
 export type FileMeta = {
   pluginKey?: KubbPlugin['key']
   name?: string
   tag?: string
 }
 
-export type PluginOptions = PluginFactoryOptions<'swagger-ts', Options, Options, never, ResolvePathOptions>
+type AppMeta = SwaggerAppMeta
+
+export type PluginOptions = PluginFactoryOptions<'swagger-ts', Options, ResolvedOptions, never, ResolvePathOptions, AppMeta>
 
 declare module '@kubb/core' {
   export interface _Register {

package/src/builders/TypeBuilder.ts

@@ -1,94 +0,0 @@
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-import { transformers } from '@kubb/core/utils'
-import { print } from '@kubb/parser'
-import * as factory from '@kubb/parser/factory'
-import { ImportsGenerator, OasBuilder } from '@kubb/swagger'
-import { refsSorter } from '@kubb/swagger/utils'
-
-import { TypeGenerator } from '../generators/TypeGenerator.ts'
-
-import type { PluginContext } from '@kubb/core'
-import type { FileResolver, Oas } from '@kubb/swagger'
-
-type Options = {
-  oas: Oas
-  usedEnumNames: Record<string, number>
-  resolveName: PluginContext['resolveName']
-  fileResolver?: FileResolver
-  withJSDocs?: boolean
-  withImports?: boolean
-  enumType: 'enum' | 'asConst' | 'asPascalConst'
-  dateType: 'string' | 'date'
-  optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
-}
-
-export class TypeBuilder extends OasBuilder<Options, never> {
-  configure(options?: Options) {
-    if (options) {
-      this.options = options
-    }
-
-    if (this.options.fileResolver) {
-      this.options.withImports = true
-    }
-
-    return this
-  }
-
-  print(name?: string): string {
-    const codes: string[] = []
-
-    const generated = this.items
-      .filter((operationSchema) => (name ? operationSchema.name === name : true))
-      .sort(transformers.nameSorter)
-      .map((operationSchema) => {
-        const generator = new TypeGenerator({
-          usedEnumNames: this.options.usedEnumNames,
-          withJSDocs: this.options.withJSDocs,
-          resolveName: this.options.resolveName,
-          enumType: this.options.enumType,
-          dateType: this.options.dateType,
-          optionalType: this.options.optionalType,
-          oas: this.options.oas,
-        })
-        const sources = generator.build({
-          schema: operationSchema.schema,
-          baseName: operationSchema.name,
-          description: operationSchema.description,
-          keysToOmit: operationSchema.keysToOmit,
-        })
-
-        return {
-          import: {
-            refs: generator.refs,
-            name: operationSchema.name,
-          },
-          sources,
-        }
-      })
-      .sort(refsSorter)
-
-    generated.forEach((item) => {
-      codes.push(print(item.sources))
-    })
-
-    if (this.options.withImports) {
-      const importsGenerator = new ImportsGenerator({ fileResolver: this.options.fileResolver })
-      const importMeta = importsGenerator.build(generated.map((item) => item.import))
-
-      if (importMeta) {
-        const nodes = importMeta.map((item) => {
-          return factory.createImportDeclaration({
-            name: [{ propertyName: item.ref.propertyName }],
-            path: item.path,
-            isTypeOnly: true,
-          })
-        })
-
-        codes.unshift(print(nodes))
-      }
-    }
-
-    return transformers.combineCodes(codes)
-  }
-}

package/src/builders/index.ts

@@ -1 +0,0 @@
-export * from './TypeBuilder.ts'

package/src/generators/OperationGenerator.ts

@@ -1,213 +0,0 @@
-import { getRelativePath } from '@kubb/core/utils'
-import { print } from '@kubb/parser'
-import * as factory from '@kubb/parser/factory'
-import { OperationGenerator as Generator, resolve } from '@kubb/swagger'
-
-import { pascalCase } from 'change-case'
-
-import { TypeBuilder } from '../builders/index.ts'
-
-import type { KubbFile } from '@kubb/core'
-import type { FileResolver, Operation, OperationSchemas, Resolver } from '@kubb/swagger'
-import type ts from 'typescript'
-import type { FileMeta, PluginOptions } from '../types.ts'
-
-type Options = {
-  usedEnumNames: Record<string, number>
-
-  mode: KubbFile.Mode
-  enumType: NonNullable<PluginOptions['options']['enumType']>
-  dateType: NonNullable<PluginOptions['options']['dateType']>
-  optionalType: NonNullable<PluginOptions['options']['optionalType']>
-}
-
-export class OperationGenerator extends Generator<Options, PluginOptions> {
-  resolve(operation: Operation): Resolver {
-    const { pluginManager, plugin } = this.context
-
-    return resolve({
-      operation,
-      resolveName: pluginManager.resolveName,
-      resolvePath: pluginManager.resolvePath,
-      pluginKey: plugin?.key,
-    })
-  }
-
-  async all(): Promise<KubbFile.File | null> {
-    return null
-  }
-
-  #printCombinedSchema(name: string, operation: Operation, schemas: OperationSchemas): string {
-    const properties: Record<string, ts.TypeNode> = {
-      'response': factory.createTypeReferenceNode(
-        factory.createIdentifier(schemas.response.name),
-        undefined,
-      ),
-    }
-
-    if (schemas.request) {
-      properties['request'] = factory.createTypeReferenceNode(
-        factory.createIdentifier(schemas.request.name),
-        undefined,
-      )
-    }
-
-    if (schemas.pathParams) {
-      properties['pathParams'] = factory.createTypeReferenceNode(
-        factory.createIdentifier(schemas.pathParams.name),
-        undefined,
-      )
-    }
-
-    if (schemas.queryParams) {
-      properties['queryParams'] = factory.createTypeReferenceNode(
-        factory.createIdentifier(schemas.queryParams.name),
-        undefined,
-      )
-    }
-
-    if (schemas.headerParams) {
-      properties['headerParams'] = factory.createTypeReferenceNode(
-        factory.createIdentifier(schemas.headerParams.name),
-        undefined,
-      )
-    }
-
-    if (schemas.errors) {
-      properties['errors'] = factory.createUnionDeclaration({
-        nodes: schemas.errors.map(error => {
-          return factory.createTypeReferenceNode(
-            factory.createIdentifier(error.name),
-            undefined,
-          )
-        }),
-      })!
-    }
-
-    const namespaceNode = factory.createNamespaceDeclaration({
-      name: operation.method === 'get' ? `${name}Query` : `${name}Mutation`,
-      statements: Object.keys(properties).map(key => {
-        const type = properties[key]
-        if (!type) {
-          return undefined
-        }
-        return factory.createTypeAliasDeclaration({
-          modifiers: [factory.modifiers.export],
-          name: pascalCase(key),
-          type,
-        })
-      }).filter(Boolean),
-    })
-
-    return print(namespaceNode)
-  }
-
-  async get(operation: Operation, schemas: OperationSchemas, options: Options): Promise<KubbFile.File<FileMeta> | null> {
-    const { mode, enumType, dateType, optionalType, usedEnumNames } = options
-    const { pluginManager, plugin, oas } = this.context
-
-    const type = this.resolve(operation)
-
-    const fileResolver: FileResolver = (name) => {
-      // Used when a react-query type(request, response, params) has an import of a global type
-      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } })
-      // refs import, will always been created with the SwaggerTS plugin, our global type
-      const resolvedTypeId = pluginManager.resolvePath({
-        baseName: `${name}.ts`,
-        pluginKey: plugin?.key,
-      })
-
-      return getRelativePath(root, resolvedTypeId)
-    }
-
-    const source = new TypeBuilder({
-      usedEnumNames,
-      fileResolver: mode === 'file' ? undefined : fileResolver,
-      withJSDocs: true,
-      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
-      enumType,
-      optionalType,
-      dateType,
-      oas,
-    })
-      .add(schemas.pathParams)
-      .add(schemas.queryParams)
-      .add(schemas.headerParams)
-      .add(schemas.response)
-      .add(schemas.errors)
-      .configure()
-      .print()
-
-    const combinedSchemaSource = this.#printCombinedSchema(type.name, operation, schemas)
-
-    return {
-      path: type.path,
-      baseName: type.baseName,
-      source: [source, combinedSchemaSource].join('\n'),
-      meta: {
-        pluginKey: plugin.key,
-        tag: operation.getTags()[0]?.name,
-      },
-    }
-  }
-
-  async post(operation: Operation, schemas: OperationSchemas, options: Options): Promise<KubbFile.File<FileMeta> | null> {
-    const { mode, enumType, dateType, optionalType, usedEnumNames } = options
-    const { pluginManager, plugin, oas } = this.context
-
-    const type = this.resolve(operation)
-
-    const fileResolver: FileResolver = (name) => {
-      // Used when a react-query type(request, response, params) has an import of a global type
-      const root = pluginManager.resolvePath({ baseName: type.baseName, pluginKey: plugin?.key, options: { tag: operation.getTags()[0]?.name } })
-      // refs import, will always been created with the SwaggerTS plugin, our global type
-      const resolvedTypeId = pluginManager.resolvePath({
-        baseName: `${name}.ts`,
-        pluginKey: plugin?.key,
-      })
-
-      return getRelativePath(root, resolvedTypeId)
-    }
-
-    const source = new TypeBuilder({
-      usedEnumNames,
-      fileResolver: mode === 'file' ? undefined : fileResolver,
-      withJSDocs: true,
-      resolveName: (params) => pluginManager.resolveName({ ...params, pluginKey: plugin?.key }),
-      enumType,
-      optionalType,
-      dateType,
-      oas,
-    })
-      .add(schemas.pathParams)
-      .add(schemas.queryParams)
-      .add(schemas.headerParams)
-      .add(schemas.request)
-      .add(schemas.response)
-      .add(schemas.errors)
-      .configure()
-      .print()
-
-    const combinedSchemaSource = this.#printCombinedSchema(type.name, operation, schemas)
-
-    return {
-      path: type.path,
-      baseName: type.baseName,
-      source: [source, combinedSchemaSource].join('\n'),
-      meta: {
-        pluginKey: plugin.key,
-        tag: operation.getTags()[0]?.name,
-      },
-    }
-  }
-
-  async put(operation: Operation, schemas: OperationSchemas, options: Options): Promise<KubbFile.File<FileMeta> | null> {
-    return this.post(operation, schemas, options)
-  }
-  async patch(operation: Operation, schemas: OperationSchemas, options: Options): Promise<KubbFile.File<FileMeta> | null> {
-    return this.post(operation, schemas, options)
-  }
-  async delete(operation: Operation, schemas: OperationSchemas, options: Options): Promise<KubbFile.File<FileMeta> | null> {
-    return this.post(operation, schemas, options)
-  }
-}

package/src/generators/index.ts

@@ -1,2 +0,0 @@
-export * from './OperationGenerator.ts'
-export * from './TypeGenerator.ts'