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

package/src/factory.ts

@@ -662,43 +662,39 @@ export const keywordTypeNodes = {
  * Converts a path like '/pet/{petId}/uploadImage' to a template literal type
  * like `/pet/${string}/uploadImage`
  */
+/**
+ * Converts an OAS-style path (e.g. `/pets/{petId}`) or an Express-style path
+ * (e.g. `/pets/:petId`) to a TypeScript template literal type
+ * like `` `/pets/${string}` ``.
+ */
 export function createUrlTemplateType(path: string): ts.TypeNode {
-  // If no parameters, return literal string type
-  if (!path.includes('{')) {
-    return factory.createLiteralTypeNode(factory.createStringLiteral(path))
-  }
+  // normalized Express `:param` → OAS `{param}` so a single regex handles both.
+  const normalized = path.replace(/:([^/]+)/g, '{$1}')
 
-  // Split path by parameter placeholders, e.g. '/pet/{petId}/upload' -> ['/pet/', 'petId', '/upload']
-  const segments = path.split(/(\{[^}]+\})/)
+  if (!normalized.includes('{')) {
+    return factory.createLiteralTypeNode(factory.createStringLiteral(normalized))
+  }
 
-  // Separate static parts from parameter placeholders
+  const segments = normalized.split(/(\{[^}]+\})/)
   const parts: string[] = []
   const parameterIndices: number[] = []
 
   segments.forEach((segment) => {
     if (segment.startsWith('{') && segment.endsWith('}')) {
-      // This is a parameter placeholder
       parameterIndices.push(parts.length)
-      parts.push(segment) // Will be replaced with ${string}
+      parts.push(segment)
     } else if (segment) {
-      // This is a static part
       parts.push(segment)
     }
   })
 
-  // Build template literal type
-  // Template literal structure: head + templateSpans[]
-  // For '/pet/{petId}/upload': head = '/pet/', spans = [{ type: string, literal: '/upload' }]
-
   const head = ts.factory.createTemplateHead(parts[0] || '')
   const templateSpans: ts.TemplateLiteralTypeSpan[] = []
 
   parameterIndices.forEach((paramIndex, i) => {
     const isLast = i === parameterIndices.length - 1
     const nextPart = parts[paramIndex + 1] || ''
-
     const literal = isLast ? ts.factory.createTemplateTail(nextPart) : ts.factory.createTemplateMiddle(nextPart)
-
     templateSpans.push(ts.factory.createTemplateLiteralTypeSpan(keywordTypeNodes.string, literal))
   })
 

package/src/generators/typeGenerator.tsx

@@ -314,7 +314,7 @@ 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()
@@ -369,7 +369,6 @@ export const typeGenerator = createReactGenerator<PluginTs>({
             description={description}
             tree={tree}
             schema={transformedSchema}
-            mapper={mapper}
             enumType={enumType}
             enumKeyCasing={enumKeyCasing}
             optionalType={optionalType}
@@ -416,7 +415,7 @@ 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()
 
@@ -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,45 +1,55 @@
+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'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
   type: 'react',
   Operation({ node, adapter, options }) {
-    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType } = options
-
-    const { plugin, mode, getFile, resolveName } = useKubb<PluginTs>()
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group } = options
+    const { mode, getFile, resolveName } = useKubb<PluginTs>()
 
     const file = getFile({
       name: node.operationId,
-      pluginName: plugin.name,
       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({
+      node: schemaNode,
+      name,
+      typedName,
+      description,
+    }: {
+      node: SchemaNode | null
+      name: string
+      typedName: string
+      description?: string
+    }) {
+      if (!schemaNode) {
+        return null
+      }
 
-    function renderSchemaType({ node: schemaNode, name, typedName, description }: { node: SchemaNode; name: string; typedName: string; description?: string }) {
       const imports = adapter.getImports(schemaNode, (schemaName) => ({
-        name: resolveName({
-          name: schemaName,
-          pluginName: plugin.name,
-          type: 'type',
-        }),
-        path: getFile({
-          name: schemaName,
-          pluginName: plugin.name,
-          extname: '.ts',
-          mode,
-        }).path,
+        name: resolveName({ name: schemaName, type: 'type' }),
+        path: getFile({ name: schemaName, extname: '.ts', mode }).path,
       }))
 
       return (
         <>
           {mode === 'split' &&
             imports.map((imp) => <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={file.path} path={imp.path} name={imp.name} isTypeOnly />)}
-
           <Type
             name={name}
             typedName={typedName}
@@ -55,122 +65,88 @@ export const typeGenerator = defineGenerator<PluginTs>({
       )
     }
 
-    // Parameter types — each parameter rendered as its own type
-    const paramTypes = node.parameters.map((param) => {
-      const name = resolveName({
-        name: `${node.operationId} ${param.name}`,
-        pluginName: plugin.name,
-        type: 'function',
-      })
-      const typedName = resolveName({
-        name: `${node.operationId} ${param.name}`,
-        pluginName: plugin.name,
-        type: 'type',
-      })
-
-      return renderSchemaType({ node: param.schema, name, typedName })
-    })
+    const paramTypes = params.map((param) =>
+      renderSchemaType({
+        node: param.schema,
+        name: resolveName({ name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`, type: 'function' }),
+        typedName: resolveName({ name: `${node.operationId} ${pascalCase(param.in)} ${param.name}`, type: 'type' }),
+      }),
+    )
 
-    // Response types
     const responseTypes = node.responses
       .filter((res) => res.schema)
-      .map((res) => {
-        const schemaNode = res.schema!
-        const responseName = `${node.operationId} ${res.statusCode}`
-        const resolvedName = resolveName({
-          name: responseName,
-          pluginName: plugin.name,
-          type: 'function',
-        })
-        const typedName = resolveName({
-          name: responseName,
-          pluginName: plugin.name,
-          type: 'type',
-        })
-
-        return renderSchemaType({ node: schemaNode, name: resolvedName, typedName, description: res.description })
-      })
+      .map((res) =>
+        renderSchemaType({
+          node: res.schema!,
+          name: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'function' }),
+          typedName: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'type' }),
+          description: res.description,
+        }),
+      )
 
-    // Request body type
     const requestType = node.requestBody
-      ? (() => {
-          const requestName = `${node.operationId} MutationRequest`
-          const resolvedName = resolveName({
-            name: requestName,
-            pluginName: plugin.name,
-            type: 'function',
-          })
-          const typedName = resolveName({
-            name: requestName,
-            pluginName: plugin.name,
-            type: 'type',
-          })
-
-          return renderSchemaType({ node: node.requestBody, name: resolvedName, typedName, description: node.requestBody.description })
-        })()
+      ? renderSchemaType({
+          node: node.requestBody,
+          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} RequestConfig`, type: 'function' }),
+      typedName: resolveName({ name: `${node.operationId} RequestConfig`, type: 'type' }),
+    })
+
+    const responsesType = renderSchemaType({
+      node: buildResponsesSchemaNode({ node, resolveName }),
+      name: resolveName({ name: `${node.operationId} Responses`, type: 'function' }),
+      typedName: resolveName({ name: `${node.operationId} Responses`, type: 'type' }),
+    })
+
+    const responseType = renderSchemaType({
+      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 (
       <File baseName={file.baseName} path={file.path} meta={file.meta}>
         {paramTypes}
         {responseTypes}
         {requestType}
+        {dataType}
+        {responsesType}
+        {responseType}
       </File>
     )
   },
   Schema({ node, adapter, options }) {
     const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType } = options
-    const { plugin, mode, resolveName, getFile } = useKubb<PluginTs>()
+    const { mode, resolveName, getFile } = useKubb<PluginTs>()
 
     if (!node.name) {
       return
     }
 
     const imports = adapter.getImports(node, (schemaName) => ({
-      name: resolveName({
-        name: schemaName,
-        pluginName: plugin.name,
-        type: 'type',
-      }),
-      path: getFile({
-        name: schemaName,
-        pluginName: plugin.name,
-        extname: '.ts',
-        mode,
-        // options: {
-        //   group
-        // },
-      }).path,
+      name: resolveName({ name: schemaName, type: 'type' }),
+      path: getFile({ name: schemaName, extname: '.ts', mode }).path,
     }))
 
     const isEnumSchema = node.type === 'enum'
 
-    let typedName = resolveName({
-      name: node.name,
-      pluginName: plugin.name,
-      type: 'type',
-    })
-
-    if (['asConst', 'asPascalConst'].includes(enumType) && isEnumSchema) {
-      typedName = typedName += 'Key'
+    let typedName = resolveName({ name: node.name, type: 'type' })
+    if (ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema) {
+      typedName += 'Key'
     }
 
     const type = {
-      name: resolveName({
-        name: node.name,
-        pluginName: plugin.name,
-        type: 'function',
-      }),
+      name: resolveName({ name: node.name, type: 'function' }),
       typedName,
-      file: getFile({
-        name: node.name,
-        pluginName: plugin.name,
-        extname: '.ts',
-        mode,
-        // options: {
-        //   group
-        // },
-      }),
+      file: getFile({ name: node.name, extname: '.ts', mode }),
     } as const
 
     return (
@@ -179,7 +155,6 @@ export const typeGenerator = defineGenerator<PluginTs>({
           imports.map((imp) => (
             <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={type.file.path} path={imp.path} name={imp.name} isTypeOnly />
           ))}
-
         <Type
           name={type.name}
           typedName={type.typedName}

package/src/generators/v2/utils.ts

@@ -0,0 +1,140 @@
+import { pascalCase } from '@internals/utils'
+import { createProperty, createSchema } from '@kubb/ast'
+import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+
+type ResolveName = (opts: { name: string; type: 'type' | 'function' }) => string
+
+type BuildParamsSchemaOptions = {
+  params: Array<ParameterNode>
+  operationId: string
+  resolveName: ResolveName
+}
+
+/**
+ * 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({
+    type: 'object',
+    properties: params.map((param) =>
+      createProperty({
+        name: param.name,
+        schema: createSchema({
+          type: 'ref',
+          name: resolveName({ name: `${operationId} ${pascalCase(param.in)} ${param.name}`, type: 'function' }),
+          optional: !param.required,
+        }),
+      }),
+    ),
+  })
+}
+
+type BuildOperationSchemaOptions = {
+  node: OperationNode
+  resolveName: ResolveName
+}
+
+/**
+ * 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`
+ * - `headerParams` → inline object of header param refs (optional), or `never`
+ * - `url`          → Express-style template literal (plugin-ts extension, handled by printer)
+ */
+export function buildDataSchemaNode({ node, resolveName }: BuildOperationSchemaOptions): SchemaNode {
+  const pathParams = node.parameters.filter((p) => p.in === 'path')
+  const queryParams = node.parameters.filter((p) => p.in === 'query')
+  const headerParams = node.parameters.filter((p) => p.in === 'header')
+
+  return createSchema({
+    type: 'object',
+    properties: [
+      createProperty({
+        name: 'data',
+        schema: node.requestBody
+          ? createSchema({
+              type: 'ref',
+              name: resolveName({ name: `${node.operationId} Data`, type: 'function' }),
+              optional: true,
+            })
+          : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'pathParams',
+        schema:
+          pathParams.length > 0
+            ? buildParamsSchema({ params: pathParams, operationId: node.operationId, resolveName })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'queryParams',
+        schema:
+          queryParams.length > 0
+            ? createSchema({ ...buildParamsSchema({ params: queryParams, operationId: node.operationId, resolveName }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'headerParams',
+        schema:
+          headerParams.length > 0
+            ? createSchema({ ...buildParamsSchema({ params: headerParams, operationId: node.operationId, resolveName }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'url',
+        schema: createSchema({ type: 'url', path: node.path }),
+      }),
+    ],
+  })
+}
+
+/**
+ * Builds an `ObjectSchemaNode` representing `<OperationId>Responses` — keyed by HTTP status code.
+ * 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)
+
+  if (responsesWithSchema.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'object',
+    properties: responsesWithSchema.map((res) =>
+      createProperty({
+        name: String(res.statusCode),
+        schema: createSchema({
+          type: 'ref',
+          name: resolveName({ name: `${node.operationId} Status ${res.statusCode}`, type: 'function' }),
+        }),
+      }),
+    ),
+  })
+}
+
+/**
+ * Builds a `UnionSchemaNode` representing `<OperationId>Response` — all response types in union format.
+ * 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)
+
+  if (responsesWithSchema.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'union',
+    members: responsesWithSchema.map((res) =>
+      createSchema({
+        type: 'ref',
+        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,
     },
@@ -167,6 +165,17 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
           { depth: 'shallow' },
         )
 
+        const barrelFiles = await getBarrelFiles(this.fabric.files, {
+          type: output.barrelType ?? 'named',
+          root,
+          output,
+          meta: {
+            pluginName: this.plugin.name,
+          },
+        })
+
+        await this.upsertFile(...barrelFiles)
+
         return
       }