@kubb/plugin-ts 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/generators/__snapshots__/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/generators/__snapshots__/stringValueConst.ts

@@ -0,0 +1,9 @@
+/**
+ * @description its value is equal to the value of the keyword
+*/
+export type stringValueConst = {
+    /**
+     * @type string | undefined
+    */
+    foobar?: "foobar";
+};

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+export { typeGenerator } from './typeGenerator.tsx'
+export { oasGenerator } from './oasGenerator.tsx'

package/src/generators/oasGenerator.tsx

@@ -0,0 +1,29 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOas } from '@kubb/plugin-oas/hooks'
+import { File, useApp } from '@kubb/react'
+import { OasType } from '../components'
+import type { PluginTs } from '../types.ts'
+
+export const oasGenerator = createReactGenerator<PluginTs>({
+  name: 'oas',
+  Operations() {
+    const {
+      pluginManager,
+      plugin: {
+        options: { output },
+        key: pluginKey,
+      },
+    } = useApp<PluginTs>()
+    const oas = useOas()
+
+    const file = pluginManager.getFile({ name: 'oas', extname: '.ts', pluginKey })
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={output?.banner} footer={output?.footer}>
+        <File.Import name={['Infer']} path="@kubb/oas" isTypeOnly />
+
+        <OasType name={'oas'} typeName={'Oas'} api={oas.api} />
+      </File>
+    )
+  },
+})

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,
@@ -54,12 +54,20 @@ export const typeKeywordMapper = {
       nodes,
     })
   },
-  const: (name?: string | number, format?: 'string' | 'number') => {
+  const: (name?: string | number | boolean, format?: 'string' | 'number' | 'boolean') => {
     if (!name) {
       return undefined
     }
 
-    if (format === 'number') {
+    if (format === 'boolean') {
+      if (name === true) {
+        return factory.createLiteralTypeNode(factory.createTrue())
+      }
+
+      return factory.createLiteralTypeNode(factory.createFalse())
+    }
+
+    if (format === 'number' && typeof name === 'number') {
       return factory.createLiteralTypeNode(factory.createNumericLiteral(name))
     }
 
@@ -95,6 +103,7 @@ export const typeKeywordMapper = {
   password: undefined,
   phone: undefined,
   readOnly: undefined,
+  writeOnly: undefined,
   ref: (propertyName?: string) => {
     if (!propertyName) {
       return undefined
@@ -120,6 +129,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,20 +3,18 @@ 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']
 
 export const pluginTs = createPlugin<PluginTs>((options) => {
   const {
-    output = { path: 'types' },
+    output = { path: 'types', barrelType: 'named' },
     group,
     exclude = [],
     include,
@@ -29,13 +27,14 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     transformers = {},
     oasType = false,
     mapper = {},
+    generators = [typeGenerator, oasType === 'infer' ? oasGenerator : undefined].filter(Boolean),
   } = options
   const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
 
   return {
     name: pluginTsName,
     options: {
-      extName: output.extName,
+      output,
       transformers,
       dateType,
       optionalType,
@@ -96,7 +95,7 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         output: output.path,
       })
 
-      const schemaFiles = await schemaGenerator.build()
+      const schemaFiles = await schemaGenerator.build(...generators)
       await this.addFile(...schemaFiles)
 
       const operationGenerator = new OperationGenerator(this.plugin.options, {
@@ -110,22 +109,21 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         mode,
       })
 
-      const operationFiles = await operationGenerator.build()
+      const operationFiles = await operationGenerator.build(...generators)
       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({
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
         root,
         output,
-        meta: { pluginKey: this.plugin.key },
+        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 { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
-import type { ts } from '@kubb/parser-ts'
+import type { Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type { Exclude, Generator, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+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'
   /**
@@ -105,29 +88,24 @@ export type Options = {
    * )
    */
   mapper?: Record<string, ts.PropertySignature>
+  /**
+   * Define some generators next to the ts generators
+   */
+  generators?: Array<Generator<PluginTs>>
 }
 
 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'