@kubb/swagger-ts 2.0.0-beta.1 → 2.0.0-beta.10

package/src/plugin.ts

@@ -1,24 +1,22 @@
 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'] = ['schema', pluginName] satisfies PluginOptions['key']
+export const pluginKey: PluginOptions['key'] = [pluginName] satisfies PluginOptions['key']
 
 export const definePlugin = createPlugin<PluginOptions>((options) => {
   const {
-    output = 'types',
+    output = { path: 'types' },
     group,
     exclude = [],
     include,
@@ -27,42 +25,44 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
     dateType = 'string',
     optionalType = 'questionToken',
     transformers = {},
-    exportAs,
+    oasType = false,
   } = options
-  const template = group?.output ? group.output : `${output}/{{tag}}Controller`
-  let pluginsOptions: [KubbPlugin<SwaggerPluginOptions>]
+  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
 
   return {
     name: pluginName,
-    options,
-    kind: 'schema',
-    validate(plugins) {
-      pluginsOptions = PluginManager.getDependedPlugins<SwaggerPluginOptions>(plugins, [swaggerPluginName])
-
-      return true
+    options: {
+      transformers,
+      dateType,
+      enumType,
+      optionalType,
+      oasType,
+      // 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)
-      const mode = FileManager.getMode(path.resolve(root, output))
+      const mode = FileManager.getMode(path.resolve(root, output.path))
 
       if (mode === 'file') {
         /**
          * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
          * Other plugins then need to call addOrAppend instead of just add from the fileManager class
          */
-        return path.resolve(root, output)
+        return path.resolve(root, output.path)
       }
 
       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)
       }
 
-      return path.resolve(root, output, baseName)
+      return path.resolve(root, output.path, 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
@@ -78,46 +78,24 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       return this.fileManager.write(source, writePath)
     },
     async buildStart() {
-      const [swaggerPlugin] = pluginsOptions
+      const [swaggerPlugin]: [KubbPlugin<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))
-      // 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 mode = FileManager.getMode(path.resolve(root, output.path))
+      const builder = new TypeBuilder(this.plugin.options, { oas, pluginManager: this.pluginManager })
 
-            const root = this.resolvePath({ baseName: ``, pluginKey: this.plugin.key })
-
-            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
@@ -125,8 +103,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,
             },
@@ -139,48 +118,26 @@ 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
         }
 
         await this.addFile({
           path: resolvedPath,
-          baseName: output as KubbFile.BaseName,
-          source: builder.print(),
+          baseName: output.path as KubbFile.BaseName,
+          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,
@@ -189,6 +146,7 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
           exclude,
           include,
           override,
+          mode,
         },
       )
 
@@ -201,31 +159,18 @@ export const definePlugin = createPlugin<PluginOptions>((options) => {
       }
 
       const root = path.resolve(this.config.root, this.config.output.path)
+      const { exportType = 'barrel' } = output
 
-      await this.fileManager.addIndexes({
-        root,
-        extName: '.ts',
-        meta: { pluginKey: this.plugin.key },
-        options: {
-          map: (file) => {
-            return {
-              ...file,
-              exports: file.exports?.map((item) => {
-                if (exportAs) {
-                  return {
-                    ...item,
-                    name: exportAs,
-                    asAlias: !!exportAs,
-                  }
-                }
-                return item
-              }),
-            }
-          },
+      if (exportType === 'barrel') {
+        await this.fileManager.addIndexes({
+          root,
           output,
-          isTypeOnly: true,
-        },
-      })
+          meta: { pluginKey: this.plugin.key },
+          options: {
+            isTypeOnly: true,
+          },
+        })
+      }
     },
   }
 })

package/src/types.ts

@@ -1,13 +1,28 @@
-import type { KubbPlugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
+import type { KubbFile, KubbPlugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { AppMeta as SwaggerAppMeta, Exclude, Include, Override, ResolvePathOptions } from '@kubb/swagger'
 
 export type Options = {
-  /**
-   * Relative path to save the TypeScript types.
-   * When output is a file it will save all models inside that file else it will create a file per schema item.
-   * @default 'types'
-   */
-  output?: string
+  output?: {
+    /**
+     * Relative path to save the TypeScript types.
+     * When output is a file it will save all models inside that file else it will create a file per schema item.
+     * @default 'types'
+     */
+    path: string
+    /**
+     * Name to be used for the `export * as {{exportAs}} from './'`
+     */
+    exportAs?: string
+    /**
+     * Add an extension to the generated imports and exports, default it will not use an extension
+     */
+    extName?: KubbFile.Extname
+    /**
+     * Define what needs to exported, here you can also disable the export of barrel files
+     * @default `'barrel'`
+     */
+    exportType?: 'barrel' | false
+  }
   /**
    * Group the TypeScript types based on the provided name.
    */
@@ -25,10 +40,6 @@ export type Options = {
      */
     output?: string
   }
-  /**
-   * Name to be used for the `export * as {{exportAs}} from './`
-   */
-  exportAs?: string
   /**
    * Array containing exclude paramaters to exclude/skip tags/operations/methods/paths.
    */
@@ -65,6 +76,19 @@ export type Options = {
      */
     name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
   }
+  /**
+   * Export an Oas object as Oas type with `import type { Infer } from '@kubb/swagger-ts/oas'`
+   */
+  oasType?: 'infer' | false
+}
+
+type ResolvedOptions = {
+  enumType: NonNullable<Options['enumType']>
+  dateType: NonNullable<Options['dateType']>
+  optionalType: NonNullable<Options['optionalType']>
+  transformers: NonNullable<Options['transformers']>
+  oasType: NonNullable<Options['oasType']>
+  usedEnumNames: Record<string, number>
 }
 
 export type FileMeta = {
@@ -73,10 +97,14 @@ export type FileMeta = {
   tag?: string
 }
 
-export type PluginOptions = PluginFactoryOptions<'swagger-ts', 'schema', 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 {
     ['@kubb/swagger-ts']: PluginOptions
   }
 }
+// external packages
+export * as Oas from './oas/index.ts'

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'