@kubb/plugin-ts 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/generators/__snapshots__/pets.ts

@@ -0,0 +1,14 @@
+export type pets = {
+    /**
+     * @type integer, int64
+    */
+    id: number;
+    /**
+     * @type string
+    */
+    name: string;
+    /**
+     * @type string | undefined
+    */
+    tag?: string;
+}[];

package/src/generators/__snapshots__/petsStoreAdvancedDiscriminator.ts

@@ -0,0 +1,31 @@
+
+ export const advancedTypeEnum2 = {
+    "enum": "enum",
+    "range": "range",
+    "regex": "regex",
+    "slider": "slider"
+} as const;
+
+ export type AdvancedTypeEnum2 = (typeof advancedTypeEnum2)[keyof typeof advancedTypeEnum2];
+
+ export type advanced = ((enumerationValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}) | (rangeValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}) | (regexValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}) | (sliderValueSpecificationDto & {
+    /**
+     * @type string
+    */
+    readonly type: AdvancedTypeEnum2;
+}));

package/src/generators/__snapshots__/petsStoreDiscriminator.ts

@@ -0,0 +1,13 @@
+/**
+ * @description A project is an analysis project. It has a name, an id, and has a dataset
+*/
+export type petstore = {
+    /**
+     * @type integer
+    */
+    id: number;
+    /**
+     * @type array | undefined
+    */
+    pets?: (cat | dog)[];
+};

package/src/generators/__snapshots__/petsStoreRef.ts

@@ -0,0 +1 @@
+export type pets = pet[];

package/src/generators/__snapshots__/plainDateDate.ts

@@ -0,0 +1 @@
+export type plainDate = Date;

package/src/generators/__snapshots__/plainDateString.ts

@@ -0,0 +1 @@
+export type plainDate = string;

package/src/generators/__snapshots__/plainEmail.ts

@@ -0,0 +1 @@
+export type plainEmail = string;

package/src/generators/__snapshots__/plainFile.ts

@@ -0,0 +1 @@
+export type plainFile = Blob;

package/src/generators/__snapshots__/plainTimeDate.ts

@@ -0,0 +1 @@
+export type plainTime = Date;

package/src/generators/__snapshots__/plainUuid.ts

@@ -0,0 +1 @@
+export type plainUuid = string;

package/src/generators/__snapshots__/readOnly.ts

@@ -0,0 +1,20 @@
+
+ export type demo = {
+    /**
+     * @type integer | undefined
+    */
+    readonly attribute_readonly?: number;
+    /**
+     * @description not required
+     * @type integer | undefined
+    */
+    attribute_writeOnly?: number;
+    /**
+     * @type integer | undefined
+    */
+    readonly attribute_with_ref?: attributeReadonly;
+    /**
+     * @type integer | undefined
+    */
+    attribute_with_ref_readonly?: attributeWriteOnly;
+};

package/src/{components/__snapshots__/Schema → generators/__snapshots__}/showPetById.ts

@@ -1,4 +1,4 @@
-export type showPetByIdPathParams = {
+export type ShowPetByIdPathParams = {
     /**
      * @description The id of the pet to retrieve
      * @type string
@@ -11,22 +11,22 @@ export type showPetByIdPathParams = {
     testId: string;
 };
 
-/**
+ /**
  * @description Expected response to a valid request
 */
-export type showPetById200 = pet;
+export type ShowPetById200 = pet;
 
-/**
+ /**
  * @description unexpected error
 */
-export type showPetByIdError = error;
+export type ShowPetByIdError = error;
 
-/**
+ /**
  * @description Expected response to a valid request
 */
-export type showPetByIdQueryResponse = pet;
+export type ShowPetByIdQueryResponse = pet;
 
-export type ShowPetByIdQuery = {
+ 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

package/src/plugin.ts

@@ -1,22 +1,20 @@
 import path from 'node:path'
 
-import { FileManager, PluginManager, createPlugin } from '@kubb/core'
+import { FileManager, type Group, 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,17 +27,13 @@ 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,
-    output: {
-      exportType: 'barrelNamed',
-      ...output,
-    },
     options: {
-      extName: output.extName,
+      output,
       transformers,
       dateType,
       optionalType,
@@ -57,6 +51,12 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
       const root = path.resolve(this.config.root, this.config.output.path)
       const mode = pathMode ?? FileManager.getMode(path.resolve(root, output.path))
 
+      if (options?.tag && group?.type === 'tag') {
+        const groupName: Group['name'] = group?.name ? group.name : (ctx) => `${ctx.group}Controller`
+
+        return path.resolve(root, output.path, groupName({ group: camelCase(options.tag) }), baseName)
+      }
+
       if (mode === 'single') {
         /**
          * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
@@ -65,12 +65,6 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         return path.resolve(root, output.path)
       }
 
-      if (options?.tag && group?.type === 'tag') {
-        const tag = camelCase(options.tag)
-
-        return path.resolve(root, renderTemplate(template, { tag }), baseName)
-      }
-
       return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
@@ -100,7 +94,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, {
@@ -114,22 +108,21 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         mode,
       })
 
-      const operationFiles = await operationGenerator.build()
+      const operationFiles = await operationGenerator.build(...generators)
       await this.addFile(...operationFiles)
 
-      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)
-      }
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
+
+      await this.addFile(...barrelFiles)
     },
   }
 })

package/src/types.ts

@@ -1,47 +1,17 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
-import type { ts } from '@kubb/parser-ts'
-import type { Exclude, Include, Override, ResolvePathOptions } from '@kubb/plugin-oas'
+import type { Group, 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
-  }
   /**
-   * Group the TypeScript types based on the provided name.
+   * Specify the export location for the files and define the behavior of the output
+   * @default { path: 'types', barrelType: 'named' }
    */
-  group?: {
-    /**
-     * Tag will group based on the operation tag inside the Swagger file.
-     */
-    type: 'tag'
-    /**
-     * Relative path to save the grouped TypeScript Types.
-     *
-     * `{{tag}}` will be replaced by the current tagName.
-     * @example `${output}/{{tag}}Controller` => `models/PetController`
-     * @default `${output}/{{tag}}Controller`
-     */
-    output?: string
-  }
+  output?: Output
+  /**
+   * Group the clients based on the provided name.
+   */
+  group?: Group
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
    */
@@ -66,7 +36,6 @@ export type Options = {
    * Default will be `'enum'` in version 3 of Kubb
    */
   enumSuffix?: string
-
   /**
    * Choose to use `date` or `datetime` as JavaScript `Date` instead of `string`.
    * @default 'string'
@@ -106,29 +75,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'