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

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,
     },