@kubb/plugin-ts 3.0.0-alpha.2 → 3.0.0-alpha.21

package/src/generators/typeGenerator.tsx

@@ -0,0 +1,200 @@
+import type { PluginManager } from '@kubb/core'
+import transformers from '@kubb/core/transformers'
+import { print } from '@kubb/parser-ts'
+import * as factory from '@kubb/parser-ts/factory'
+import { type OperationSchema as OperationSchemaType, type OperationSchemas, SchemaGenerator, createReactGenerator, schemaKeywords } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { File, useApp } from '@kubb/react'
+import type ts from 'typescript'
+import { Type } from '../components'
+import type { PluginTs } from '../types'
+
+function printCombinedSchema({ name, schemas, pluginManager }: { name: string; schemas: OperationSchemas; pluginManager: PluginManager }): string {
+  const properties: Record<string, ts.TypeNode> = {}
+
+  if (schemas.response) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.response.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['response'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.request) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.request.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['request'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.pathParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.pathParams.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['pathParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.queryParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.queryParams.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['queryParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.headerParams) {
+    const identifier = pluginManager.resolveName({
+      name: schemas.headerParams.name,
+      pluginKey: [pluginTsName],
+      type: 'function',
+    })
+    properties['headerParams'] = factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+  }
+
+  if (schemas.errors) {
+    properties['errors'] = factory.createUnionDeclaration({
+      nodes: schemas.errors.map((error) => {
+        const identifier = pluginManager.resolveName({
+          name: error.name,
+          pluginKey: [pluginTsName],
+          type: 'function',
+        })
+
+        return factory.createTypeReferenceNode(factory.createIdentifier(identifier), undefined)
+      }),
+    })!
+  }
+
+  const namespaceNode = factory.createTypeAliasDeclaration({
+    name,
+    type: factory.createTypeLiteralNode(
+      Object.keys(properties)
+        .map((key) => {
+          const type = properties[key]
+          if (!type) {
+            return undefined
+          }
+
+          return factory.createPropertySignature({
+            name: transformers.pascalCase(key),
+            type,
+          })
+        })
+        .filter(Boolean),
+    ),
+    modifiers: [factory.modifiers.export],
+  })
+
+  return print([namespaceNode])
+}
+
+export const typeGenerator = createReactGenerator<PluginTs>({
+  name: 'typescript',
+  Operation({ operation, options }) {
+    const { mapper, enumType, optionalType } = options
+
+    const { plugin, pluginManager, mode } = useApp<PluginTs>()
+    const oas = useOas()
+    const { getSchemas, getFile, getName } = useOperationManager()
+    const schemaManager = useSchemaManager()
+
+    const file = getFile(operation)
+    const schemas = getSchemas(operation)
+    const type = getName(operation, { type: 'function', pluginKey: [pluginTsName] })
+    const combinedSchemaName = operation.method === 'get' ? `${type}Query` : `${type}Mutation`
+    const schemaGenerator = new SchemaGenerator(options, {
+      oas,
+      plugin,
+      pluginManager,
+      mode,
+      override: options.override,
+    })
+
+    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
+      .flat()
+      .filter(Boolean)
+
+    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }: OperationSchemaType, i: number) => {
+      // hack so Params can be optional when needed
+      const tree = schemaGenerator.parse({ schema, name })
+      const imports = schemaManager.getImports(tree)
+
+      const type = {
+        name: schemaManager.getName(name, { type: 'type' }),
+        typedName: schemaManager.getName(name, { type: 'type' }),
+        file: schemaManager.getFile(options.operationName || name, { tag: options.operation?.getTags()[0]?.name }),
+      }
+
+      return (
+        <Oas.Schema key={i} name={name} value={schema} tree={tree}>
+          {mode === 'split' && imports.map((imp, index) => <File.Import key={index} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
+          <Type
+            name={type.name}
+            typedName={type.typedName}
+            description={description}
+            tree={tree}
+            mapper={mapper}
+            enumType={enumType}
+            optionalType={optionalType}
+            keysToOmit={keysToOmit}
+          />
+        </Oas.Schema>
+      )
+    }
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={plugin.options.output?.banner} footer={plugin.options.output?.footer}>
+        {operationSchemas.map(mapOperationSchema)}
+
+        <File.Source name={combinedSchemaName} isExportable isIndexable isTypeOnly>
+          {printCombinedSchema({ name: combinedSchemaName, schemas, pluginManager })}
+        </File.Source>
+      </File>
+    )
+  },
+  Schema({ schema, options }) {
+    const { mapper, enumType, optionalType } = options
+    const {
+      mode,
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginTs>()
+
+    const { getName, getImports, getFile } = useSchemaManager()
+    const imports = getImports(schema.tree)
+
+    if (enumType === 'asPascalConst') {
+      console.warn(`enumType '${enumType}' is deprecated`)
+    }
+
+    const type = {
+      name: getName(schema.name, { type: 'function' }),
+      typedName: getName(schema.name, { type: 'type' }),
+      file: getFile(schema.name),
+    }
+
+    return (
+      <File baseName={type.file.baseName} path={type.file.path} meta={type.file.meta} banner={output?.banner} footer={output?.footer}>
+        {mode === 'split' && imports.map((imp, index) => <File.Import key={index} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />)}
+        <Type
+          name={type.name}
+          typedName={type.typedName}
+          description={schema.value.description}
+          tree={schema.tree}
+          mapper={mapper}
+          enumType={enumType}
+          optionalType={optionalType}
+        />
+      </File>
+    )
+  },
+})

package/src/parser/index.ts

@@ -2,8 +2,8 @@ import transformers from '@kubb/core/transformers'
 import * as factory from '@kubb/parser-ts/factory'
 import { isKeyword, schemaKeywords } from '@kubb/plugin-oas'
 
-import type { ts } from '@kubb/parser-ts'
 import type { Schema, SchemaKeywordMapper, SchemaMapper } from '@kubb/plugin-oas'
+import type ts from 'typescript'
 
 export const typeKeywordMapper = {
   any: () => factory.keywordTypeNodes.any,
@@ -120,6 +120,7 @@ type ParserOptions = {
   optionalType: 'questionToken' | 'undefined' | 'questionTokenAndUndefined'
   /**
    * @default `'asConst'`
+   * asPascalConst is deprecated
    */
   enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'
   keysToOmit?: string[]

package/src/plugin.ts

@@ -3,13 +3,11 @@ import path from 'node:path'
 import { FileManager, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
 import { renderTemplate } from '@kubb/core/utils'
-import { pluginOasName } from '@kubb/plugin-oas'
-
-import { OperationGenerator } from './OperationGenerator.tsx'
-import { SchemaGenerator } from './SchemaGenerator.tsx'
+import { OperationGenerator, SchemaGenerator, pluginOasName } from '@kubb/plugin-oas'
 
 import type { Plugin } from '@kubb/core'
 import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { oasGenerator, typeGenerator } from './generators'
 import type { PluginTs } from './types.ts'
 
 export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
@@ -35,7 +33,10 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
   return {
     name: pluginTsName,
     options: {
-      extName: output.extName,
+      output: {
+        exportType: 'barrelNamed',
+        ...output,
+      },
       transformers,
       dateType,
       optionalType,
@@ -96,7 +97,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         output: output.path,
       })
 
-      const schemaFiles = await schemaGenerator.build()
+      const schemaFiles = await schemaGenerator.build(...[typeGenerator, oasType === 'infer' ? oasGenerator : undefined].filter(Boolean))
       await this.addFile(...schemaFiles)
 
       const operationGenerator = new OperationGenerator(this.plugin.options, {
@@ -110,22 +111,22 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         mode,
       })
 
-      const operationFiles = await operationGenerator.build()
+      const operationFiles = await operationGenerator.build(...[typeGenerator, oasType === 'infer' ? oasGenerator : undefined].filter(Boolean))
       await this.addFile(...operationFiles)
-    },
-    async buildEnd() {
-      if (this.config.output.write === false) {
-        return
-      }
 
-      const root = path.resolve(this.config.root, this.config.output.path)
-
-      await this.fileManager.addIndexes({
-        root,
-        output,
-        meta: { pluginKey: this.plugin.key },
-        logger: this.logger,
-      })
+      if (this.config.output.exportType) {
+        const barrelFiles = await this.fileManager.getBarrelFiles({
+          root,
+          output,
+          files: this.fileManager.files,
+          meta: {
+            pluginKey: this.plugin.key,
+          },
+          logger: this.logger,
+        })
+
+        await this.addFile(...barrelFiles)
+      }
     },
   }
 })

package/src/types.ts

@@ -1,30 +1,12 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
+import type { Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { ts } from '@kubb/parser-ts'
+import type ts from 'typescript'
 
 export type Options = {
-  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' | 'barrelNamed' | false
-  }
+  /**
+   * @default 'types'
+   */
+  output?: Output
   /**
    * Group the TypeScript types based on the provided name.
    */
@@ -57,6 +39,7 @@ export type Options = {
   /**
    * Choose to use `enum` or `as const` for enums
    * @default 'asConst'
+   * asPascalConst is deprecated
    */
   enumType?: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal'
   /**
@@ -108,26 +91,17 @@ export type Options = {
 }
 
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
+  output: Output
+  override: NonNullable<Options['override']>
   enumType: NonNullable<Options['enumType']>
   enumSuffix: NonNullable<Options['enumSuffix']>
   dateType: NonNullable<Options['dateType']>
   unknownType: NonNullable<Options['unknownType']>
   optionalType: NonNullable<Options['optionalType']>
-  override: NonNullable<Options['override']>
   transformers: NonNullable<Options['transformers']>
   oasType: NonNullable<Options['oasType']>
   usedEnumNames: Record<string, number>
   mapper: Record<string, any>
 }
 
-export type FileMeta = {
-  pluginKey?: Plugin['key']
-  name?: string
-  tag?: string
-}
-
 export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions>
-
-// external packages
-export * as Oas from './oas/index.ts'