@kubb/plugin-ts 5.0.0-alpha.5 → 5.0.0-alpha.7

package/src/generators/typeGenerator.tsx

@@ -1,6 +1,6 @@
 import { pascalCase } from '@internals/utils'
-import type { PluginManager } from '@kubb/core'
-import { useMode, usePluginManager } from '@kubb/core/hooks'
+import type { PluginDriver } from '@kubb/core'
+import { useMode, usePluginDriver } from '@kubb/core/hooks'
 import { safePrint } from '@kubb/fabric-core/parsers/typescript'
 import type { Operation } from '@kubb/oas'
 import { isKeyword, type OperationSchemas, type OperationSchema as OperationSchemaType, SchemaGenerator, schemaKeywords } from '@kubb/plugin-oas'
@@ -15,13 +15,13 @@ import { createUrlTemplateType, getUnknownType, keywordTypeNodes } from '../fact
 import { pluginTsName } from '../plugin.ts'
 import type { PluginTs } from '../types'
 
-function printCombinedSchema({ name, schemas, pluginManager }: { name: string; schemas: OperationSchemas; pluginManager: PluginManager }): string {
+function printCombinedSchema({ name, schemas, driver }: { name: string; schemas: OperationSchemas; driver: PluginDriver }): string {
   const properties: Record<string, ts.TypeNode> = {}
 
   if (schemas.response) {
     properties['response'] = factory.createUnionDeclaration({
       nodes: schemas.responses.map((res) => {
-        const identifier = pluginManager.resolveName({
+        const identifier = driver.resolveName({
           name: res.name,
           pluginName: pluginTsName,
           type: 'function',
@@ -33,7 +33,7 @@ function printCombinedSchema({ name, schemas, pluginManager }: { name: string; s
   }
 
   if (schemas.request) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.request.name,
       pluginName: pluginTsName,
       type: 'function',
@@ -42,7 +42,7 @@ function printCombinedSchema({ name, schemas, pluginManager }: { name: string; s
   }
 
   if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.pathParams.name,
       pluginName: pluginTsName,
       type: 'function',
@@ -51,7 +51,7 @@ function printCombinedSchema({ name, schemas, pluginManager }: { name: string; s
   }
 
   if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.queryParams.name,
       pluginName: pluginTsName,
       type: 'function',
@@ -60,7 +60,7 @@ function printCombinedSchema({ name, schemas, pluginManager }: { name: string; s
   }
 
   if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.headerParams.name,
       pluginName: pluginTsName,
       type: 'function',
@@ -71,7 +71,7 @@ function printCombinedSchema({ name, schemas, pluginManager }: { name: string; s
   if (schemas.errors) {
     properties['errors'] = factory.createUnionDeclaration({
       nodes: schemas.errors.map((error) => {
-        const identifier = pluginManager.resolveName({
+        const identifier = driver.resolveName({
           name: error.name,
           pluginName: pluginTsName,
           type: 'function',
@@ -109,14 +109,14 @@ function printRequestSchema({
   baseName,
   operation,
   schemas,
-  pluginManager,
+  driver,
 }: {
   baseName: string
   operation: Operation
   schemas: OperationSchemas
-  pluginManager: PluginManager
+  driver: PluginDriver
 }): string {
-  const name = pluginManager.resolveName({
+  const name = driver.resolveName({
     name: `${baseName} Request`,
     pluginName: pluginTsName,
     type: 'type',
@@ -128,7 +128,7 @@ function printRequestSchema({
   const dataRequestProperties: ts.PropertySignature[] = []
 
   if (schemas.request) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.request.name,
       pluginName: pluginTsName,
       type: 'type',
@@ -152,7 +152,7 @@ function printRequestSchema({
 
   // Add pathParams property
   if (schemas.pathParams) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.pathParams.name,
       pluginName: pluginTsName,
       type: 'type',
@@ -175,7 +175,7 @@ function printRequestSchema({
 
   // Add queryParams property
   if (schemas.queryParams) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.queryParams.name,
       pluginName: pluginTsName,
       type: 'type',
@@ -199,7 +199,7 @@ function printRequestSchema({
 
   // Add headerParams property
   if (schemas.headerParams) {
-    const identifier = pluginManager.resolveName({
+    const identifier = driver.resolveName({
       name: schemas.headerParams.name,
       pluginName: pluginTsName,
       type: 'type',
@@ -243,17 +243,17 @@ function printRequestSchema({
 function printResponseSchema({
   baseName,
   schemas,
-  pluginManager,
+  driver,
   unknownType,
 }: {
   baseName: string
   schemas: OperationSchemas
-  pluginManager: PluginManager
+  driver: PluginDriver
   unknownType: PluginTs['resolvedOptions']['unknownType']
 }): string {
   const results: string[] = []
 
-  const name = pluginManager.resolveName({
+  const name = driver.resolveName({
     name: `${baseName} ResponseData`,
     pluginName: pluginTsName,
     type: 'type',
@@ -262,7 +262,7 @@ function printResponseSchema({
   // Generate Responses type (mapping status codes to response types)
   if (schemas.responses && schemas.responses.length > 0) {
     const responsesProperties: ts.PropertySignature[] = schemas.responses.map((res) => {
-      const identifier = pluginManager.resolveName({
+      const identifier = driver.resolveName({
         name: res.name,
         pluginName: pluginTsName,
         type: 'type',
@@ -314,11 +314,11 @@ export const typeGenerator = createReactGenerator<PluginTs>({
   Operation({ operation, generator, plugin }) {
     const {
       options,
-      options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing },
+      options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, unknownType, paramsCasing },
     } = plugin
 
     const mode = useMode()
-    const pluginManager = usePluginManager()
+    const driver = usePluginDriver()
 
     const oas = useOas()
     const { getSchemas, getFile, getName, getGroup } = useOperationManager(generator)
@@ -333,7 +333,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
       oas,
       events: generator.context.events,
       plugin,
-      pluginManager,
+      driver,
       mode,
       override: options.override,
     })
@@ -369,7 +369,6 @@ export const typeGenerator = createReactGenerator<PluginTs>({
             description={description}
             tree={tree}
             schema={transformedSchema}
-            mapper={mapper}
             enumType={enumType}
             enumKeyCasing={enumKeyCasing}
             optionalType={optionalType}
@@ -392,7 +391,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
         baseName={file.baseName}
         path={file.path}
         meta={file.meta}
-        banner={getBanner({ oas, output: plugin.options.output, config: pluginManager.config })}
+        banner={getBanner({ oas, output: plugin.options.output, config: driver.config })}
         footer={getFooter({ oas, output: plugin.options.output })}
       >
         {operationSchemas.map(mapOperationSchema)}
@@ -400,15 +399,15 @@ export const typeGenerator = createReactGenerator<PluginTs>({
         {generator.context.UNSTABLE_NAMING ? (
           <>
             <File.Source name={`${name}Request`} isExportable isIndexable isTypeOnly>
-              {printRequestSchema({ baseName: name, operation, schemas, pluginManager })}
+              {printRequestSchema({ baseName: name, operation, schemas, driver })}
             </File.Source>
             <File.Source name={responseName} isExportable isIndexable isTypeOnly>
-              {printResponseSchema({ baseName: name, schemas, pluginManager, unknownType })}
+              {printResponseSchema({ baseName: name, schemas, driver, unknownType })}
             </File.Source>
           </>
         ) : (
           <File.Source name={combinedSchemaName} isExportable isIndexable isTypeOnly>
-            {printCombinedSchema({ name: combinedSchemaName, schemas, pluginManager })}
+            {printCombinedSchema({ name: combinedSchemaName, schemas, driver })}
           </File.Source>
         )}
       </File>
@@ -416,12 +415,12 @@ export const typeGenerator = createReactGenerator<PluginTs>({
   },
   Schema({ schema, plugin }) {
     const {
-      options: { mapper, enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output },
+      options: { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output },
     } = plugin
     const mode = useMode()
 
     const oas = useOas()
-    const pluginManager = usePluginManager()
+    const driver = usePluginDriver()
 
     const { getName, getFile } = useSchemaManager()
     const imports = getImports(schema.tree)
@@ -444,7 +443,7 @@ export const typeGenerator = createReactGenerator<PluginTs>({
         baseName={type.file.baseName}
         path={type.file.path}
         meta={type.file.meta}
-        banner={getBanner({ oas, output, config: pluginManager.config })}
+        banner={getBanner({ oas, output, config: driver.config })}
         footer={getFooter({ oas, output })}
       >
         {mode === 'split' &&
@@ -457,7 +456,6 @@ export const typeGenerator = createReactGenerator<PluginTs>({
           description={schema.value.description}
           tree={schema.tree}
           schema={schema.value}
-          mapper={mapper}
           enumType={enumType}
           enumKeyCasing={enumKeyCasing}
           optionalType={optionalType}

package/src/generators/v2/typeGenerator.tsx

@@ -1,9 +1,11 @@
+import { pascalCase } from '@internals/utils'
 import { applyParamsCasing } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
 import { defineGenerator } from '@kubb/core'
 import { useKubb } from '@kubb/core/hooks'
 import { File } from '@kubb/react-fabric'
 import { Type } from '../../components/v2/Type.tsx'
+import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../../constants.ts'
 import type { PluginTs } from '../../types'
 import { buildDataSchemaNode, buildResponsesSchemaNode, buildResponseUnionSchemaNode } from './utils.ts'
 
@@ -11,10 +13,17 @@ export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
   Operation({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, mapper } = options
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options
     const { mode, getFile, resolveName } = useKubb<PluginTs>()
 
-    const file = getFile({ name: node.operationId, extname: '.ts', mode })
+    const file = getFile({
+      name: node.operationId,
+      extname: '.ts',
+      mode,
+      options: {
+        group: group ? (group.type === 'tag' ? { tag: node.tags[0] } : { path: node.path }) : undefined,
+      },
+    })
     const params = applyParamsCasing(node.parameters, paramsCasing)
 
     function renderSchemaType({
@@ -51,7 +60,6 @@ export const typeGenerator = defineGenerator<PluginTs>({
             optionalType={optionalType}
             arrayType={arrayType}
             syntaxType={syntaxType}
-            mapper={mapper}
           />
         </>
       )
@@ -60,8 +68,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
     const paramTypes = params.map((param) =>
       renderSchemaType({
         node: param.schema,
-        name: resolveName({ name: `${node.operationId} ${param.name}`, type: 'function' }),
-        typedName: resolveName({ name: `${node.operationId} ${param.name}`, type: 'type' }),
+        name: resolveName({ name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`, type: 'function' }),
+        typedName: resolveName({ name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`, type: 'type' }),
       }),
     )
 
@@ -70,8 +78,8 @@ export const typeGenerator = defineGenerator<PluginTs>({
       .map((res) =>
         renderSchemaType({
           node: res.schema!,
-          name: resolveName({ name: `${node.operationId} ${res.statusCode}`, type: 'function' }),
-          typedName: resolveName({ name: `${node.operationId} ${res.statusCode}`, type: 'type' }),
+          name: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'function' }),
+          typedName: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'type' }),
           description: res.description,
         }),
       )
@@ -79,16 +87,16 @@ export const typeGenerator = defineGenerator<PluginTs>({
     const requestType = node.requestBody
       ? renderSchemaType({
           node: node.requestBody,
-          name: resolveName({ name: `${node.operationId} MutationRequest`, type: 'function' }),
-          typedName: resolveName({ name: `${node.operationId} MutationRequest`, type: 'type' }),
+          name: resolveName({ name: `${node.operationId} Data`, type: 'function' }),
+          typedName: resolveName({ name: `${node.operationId} Data`, type: 'type' }),
           description: node.requestBody.description,
         })
       : null
 
     const dataType = renderSchemaType({
       node: buildDataSchemaNode({ node: { ...node, parameters: params }, resolveName }),
-      name: resolveName({ name: `${node.operationId} Data`, type: 'function' }),
-      typedName: resolveName({ name: `${node.operationId} Data`, type: 'type' }),
+      name: resolveName({ name: `${node.operationId} RequestConfig`, type: 'function' }),
+      typedName: resolveName({ name: `${node.operationId} RequestConfig`, type: 'type' }),
     })
 
     const responsesType = renderSchemaType({
@@ -101,6 +109,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       node: buildResponseUnionSchemaNode({ node, resolveName }),
       name: resolveName({ name: `${node.operationId} Response`, type: 'function' }),
       typedName: resolveName({ name: `${node.operationId} Response`, type: 'type' }),
+      description: 'Union of all possible responses',
     })
 
     return (
@@ -115,7 +124,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
     )
   },
   Schema({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, mapper } = options
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options
     const { mode, resolveName, getFile } = useKubb<PluginTs>()
 
     if (!node.name) {
@@ -130,7 +139,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
     const isEnumSchema = node.type === 'enum'
 
     let typedName = resolveName({ name: node.name, type: 'type' })
-    if (['asConst', 'asPascalConst'].includes(enumType) && isEnumSchema) {
+    if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema) {
       typedName += 'Key'
     }
 
@@ -155,7 +164,6 @@ export const typeGenerator = defineGenerator<PluginTs>({
           optionalType={optionalType}
           arrayType={arrayType}
           syntaxType={syntaxType}
-          mapper={mapper}
         />
       </File>
     )

package/src/generators/v2/utils.ts

@@ -1,3 +1,4 @@
+import { pascalCase } from '@internals/utils'
 import { createProperty, createSchema } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
 
@@ -12,6 +13,8 @@ type BuildParamsSchemaOptions = {
 /**
  * Builds an `ObjectSchemaNode` for a group of parameters (path/query/header).
  * Each property is a `ref` schema pointing to the individually-resolved parameter type.
+ * The ref name includes the parameter location so generated type names follow
+ * the `<OperationId><Location><ParamName>` convention.
  */
 export function buildParamsSchema({ params, operationId, resolveName }: BuildParamsSchemaOptions): SchemaNode {
   return createSchema({
@@ -21,7 +24,7 @@ export function buildParamsSchema({ params, operationId, resolveName }: BuildPar
         name: param.name,
         schema: createSchema({
           type: 'ref',
-          name: resolveName({ name: `${operationId} ${param.name}`, type: 'function' }),
+          name: resolveName({ name: `${operationId} ${pascalCase(param.in)} ${param.name}`, type: 'function' }),
           optional: !param.required,
         }),
       }),
@@ -35,7 +38,7 @@ type BuildOperationSchemaOptions = {
 }
 
 /**
- * Builds an `ObjectSchemaNode` representing the `<OperationId>Data` type:
+ * Builds an `ObjectSchemaNode` representing the `<OperationId>RequestConfig` type:
  * - `data`         → request body ref (optional) or `never`
  * - `pathParams`   → inline object of path param refs, or `never`
  * - `queryParams`  → inline object of query param refs (optional), or `never`
@@ -55,7 +58,7 @@ export function buildDataSchemaNode({ node, resolveName }: BuildOperationSchemaO
         schema: node.requestBody
           ? createSchema({
               type: 'ref',
-              name: resolveName({ name: `${node.operationId} MutationRequest`, type: 'function' }),
+              name: resolveName({ name: `${node.operationId} Data`, type: 'function' }),
               optional: true,
             })
           : createSchema({ type: 'never', optional: true }),
@@ -91,11 +94,7 @@ export function buildDataSchemaNode({ node, resolveName }: BuildOperationSchemaO
 
 /**
  * Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
- *
- * Example output:
- * ```ts
- * export type PlaceOrderPatchResponses = { 200: PlaceOrderPatch200; 405: PlaceOrderPatch405 }
- * ```
+ * Numeric status codes produce unquoted numeric keys (e.g. `200:`).
  */
 export function buildResponsesSchemaNode({ node, resolveName }: BuildOperationSchemaOptions): SchemaNode | null {
   const responsesWithSchema = node.responses.filter((res) => res.schema)
@@ -111,7 +110,7 @@ export function buildResponsesSchemaNode({ node, resolveName }: BuildOperationSc
         name: String(res.statusCode),
         schema: createSchema({
           type: 'ref',
-          name: resolveName({ name: `${node.operationId} ${res.statusCode}`, type: 'function' }),
+          name: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'function' }),
         }),
       }),
     ),
@@ -120,11 +119,7 @@ export function buildResponsesSchemaNode({ node, resolveName }: BuildOperationSc
 
 /**
  * Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
- *
- * Example output:
- * ```ts
- * export type PlaceOrderPatchResponse = PlaceOrderPatch200 | PlaceOrderPatch405
- * ```
+ * Returns `null` when the operation has no responses with schemas.
  */
 export function buildResponseUnionSchemaNode({ node, resolveName }: BuildOperationSchemaOptions): SchemaNode | null {
   const responsesWithSchema = node.responses.filter((res) => res.schema)
@@ -138,7 +133,7 @@ export function buildResponseUnionSchemaNode({ node, resolveName }: BuildOperati
     members: responsesWithSchema.map((res) =>
       createSchema({
         type: 'ref',
-        name: resolveName({ name: `${node.operationId} ${res.statusCode}`, type: 'function' }),
+        name: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'function' }),
       }),
     ),
   })

package/src/parser.ts

@@ -159,7 +159,6 @@ type ParserOptions = {
    * @note In Kubb v5, `inlineLiteral` becomes the default.
    */
   enumType: 'enum' | 'asConst' | 'asPascalConst' | 'constEnum' | 'literal' | 'inlineLiteral'
-  mapper?: Record<string, ts.PropertySignature>
 }
 
 /**
@@ -170,7 +169,7 @@ type ParserOptions = {
  * @param current - The schema node to parse.
  * @param siblings - Sibling schema nodes, used for context in certain mappings.
  * @param name - The name of the schema or property being parsed.
- * @param options - Parsing options controlling output style, property handling, and custom mappers.
+ * @param options - Parsing options controlling output style, property handling.
  * @returns The generated TypeScript AST node, or `undefined` if the schema keyword is not mapped.
  */
 export const parse = createParser<ts.Node | null, ParserOptions>({
@@ -254,12 +253,6 @@ export const parse = createParser<ts.Node | null, ParserOptions>({
           const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
           const mappedName = nameSchema?.args || name
 
-          // custom mapper(pluginOptions)
-          // Use Object.hasOwn to avoid matching inherited properties like 'toString', 'valueOf', etc.
-          if (options.mapper && Object.hasOwn(options.mapper, mappedName)) {
-            return options.mapper[mappedName]
-          }
-
           const isNullish = schemas.some((schema) => schema.keyword === schemaKeywords.nullish)
           const isNullable = schemas.some((schema) => schema.keyword === schemaKeywords.nullable)
           const isOptional = schemas.some((schema) => schema.keyword === schemaKeywords.optional)

package/src/plugin.ts

@@ -26,7 +26,6 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     emptySchemaType = unknownType,
     syntaxType = 'type',
     transformers = {},
-    mapper = {},
     paramsCasing,
     generators = [typeGenerator, typeGeneratorV2].filter(Boolean),
     contentType,
@@ -53,7 +52,6 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       syntaxType,
       group,
       override,
-      mapper,
       paramsCasing,
       usedEnumNames,
     },
@@ -102,7 +100,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       return resolvedName
     },
     async install() {
-      const { config, fabric, plugin, adapter, rootNode, pluginManager, openInStudio } = this
+      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio } = this
 
       const root = path.resolve(config.root, config.output.path)
       const mode = getMode(path.resolve(root, output.path))
@@ -129,7 +127,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
                     fabric,
                     Component: generator.Schema,
                     plugin,
-                    pluginManager,
+                    driver,
                     mode,
                     version: generator.version,
                   })
@@ -154,7 +152,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
                     fabric,
                     Component: generator.Operation,
                     plugin,
-                    pluginManager,
+                    driver,
                     mode,
                     version: generator.version,
                   })
@@ -188,7 +186,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       const schemaGenerator = new SchemaGenerator(this.plugin.options, {
         fabric: this.fabric,
         oas,
-        pluginManager: this.pluginManager,
+        driver: this.driver,
         events: this.events,
         plugin: this.plugin,
         contentType,
@@ -204,7 +202,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       const operationGenerator = new OperationGenerator(this.plugin.options, {
         fabric: this.fabric,
         oas,
-        pluginManager: this.pluginManager,
+        driver: this.driver,
         events: this.events,
         plugin: this.plugin,
         contentType,