@kubb/plugin-ts 5.0.0-beta.30 → 5.0.0-beta.33

package/extension.yaml

@@ -707,7 +707,9 @@ options:
       | --- | --- |
       | `@kubb/plugin-ts` | `resolverTs` |
       | `@kubb/plugin-zod` | `resolverZod` |
+      | `@kubb/plugin-faker` | `resolverFaker` |
       | `@kubb/plugin-cypress` | `resolverCypress` |
+      | `@kubb/plugin-msw` | `resolverMsw` |
       | `@kubb/plugin-mcp` | `resolverMcp` |
       | `@kubb/plugin-client` | `resolverClient` |
     codeBlock:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-beta.30",
+  "version": "5.0.0-beta.33",
   "description": "Generate TypeScript types, interfaces, and enums from your OpenAPI specification. The foundational plugin that powers type safety across the entire Kubb ecosystem.",
   "keywords": [
     "code-generation",
@@ -46,10 +46,10 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/core": "5.0.0-beta.29",
-    "@kubb/parser-ts": "5.0.0-beta.29",
-    "@kubb/renderer-jsx": "5.0.0-beta.29",
-    "remeda": "^2.34.1",
+    "@kubb/core": "5.0.0-beta.33",
+    "@kubb/parser-ts": "5.0.0-beta.33",
+    "@kubb/renderer-jsx": "5.0.0-beta.33",
+    "remeda": "^2.36.0",
     "typescript": "^6.0.3"
   },
   "devDependencies": {
@@ -57,7 +57,7 @@
     "@internals/utils": "0.0.0"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.29"
+    "@kubb/renderer-jsx": "5.0.0-beta.33"
   },
   "size-limit": [
     {

package/src/generators/typeGenerator.tsx

@@ -1,3 +1,4 @@
+import { resolveContentTypeVariants } from '@internals/shared'
 import { ast, defineGenerator } from '@kubb/core'
 import { File, jsxRendererSync } from '@kubb/renderer-jsx'
 import { Type } from '../components/Type.tsx'
@@ -6,24 +7,6 @@ import { printerTs } from '../printers/printerTs.ts'
 import type { PluginTs } from '../types'
 import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
 
-function getContentTypeSuffix(contentType: string): string {
-  const baseType = contentType.split(';')[0]!.trim()
-  if (baseType === 'application/json') return 'Json'
-  if (baseType === 'multipart/form-data') return 'FormData'
-  if (baseType === 'application/x-www-form-urlencoded') return 'FormUrlEncoded'
-  const subtype = baseType.split('/').pop() ?? baseType
-  const parts = subtype.split(/[^a-zA-Z0-9]+/).filter(Boolean)
-  if (parts.length === 0) return 'Unknown'
-  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')
-}
-
-function getPerContentTypeName(dataName: string, suffix: string): string {
-  if (dataName.endsWith('Data')) {
-    return suffix.endsWith('Data') ? dataName.slice(0, -4) + suffix : `${dataName.slice(0, -4)}${suffix}Data`
-  }
-  return dataName + suffix
-}
-
 /**
  * Built-in generator for `@kubb/plugin-ts`. Emits one TypeScript file per
  * schema in the spec plus per-operation request, response, and parameter
@@ -168,6 +151,34 @@ export const typeGenerator = defineGenerator<PluginTs>({
       )
     }
 
+    /**
+     * Emits an individual type per content type plus a union alias under `baseName`.
+     * Shared by the request body and multi-content-type responses.
+     */
+    function buildContentTypeVariants(
+      entries: Array<{ contentType: string; schema?: ast.SchemaNode | null; keysToOmit?: Array<string> | null }>,
+      baseName: string,
+      decorate?: (schema: ast.SchemaNode) => ast.SchemaNode,
+    ) {
+      const variants = resolveContentTypeVariants(entries, baseName)
+      const unionSchema = ast.createSchema({
+        type: 'union',
+        members: variants.map((variant) => ast.createSchema({ type: 'ref', name: variant.name })),
+      })
+      return (
+        <>
+          {variants.map((variant) =>
+            renderSchemaType({
+              schema: decorate ? decorate(variant.schema) : variant.schema,
+              name: variant.name,
+              keysToOmit: variant.keysToOmit,
+            }),
+          )}
+          {renderSchemaType({ schema: unionSchema, name: baseName })}
+        </>
+      )
+    }
+
     const paramTypes = params.map((param) =>
       renderSchemaType({
         schema: param.schema,
@@ -192,52 +203,27 @@ export const typeGenerator = defineGenerator<PluginTs>({
         })
       }
       // Multiple content types — generate individual types + union alias
-      const dataName = resolver.resolveDataName(node)
-      const usedNames = new Set<string>()
-      const individualItems = requestBodyContent
-        .filter((entry) => entry.schema)
-        .map((entry) => {
-          const baseSuffix = getContentTypeSuffix(entry.contentType)
-          let individualName = getPerContentTypeName(dataName, baseSuffix)
-          let counter = 2
-          while (usedNames.has(individualName)) {
-            individualName = getPerContentTypeName(dataName, `${baseSuffix}${counter++}`)
-          }
-          usedNames.add(individualName)
-          return {
-            name: individualName,
-            rendered: renderSchemaType({
-              schema: {
-                ...entry.schema!,
-                description: node.requestBody!.description ?? entry.schema!.description,
-              },
-              name: individualName,
-              keysToOmit: entry.keysToOmit,
-            }),
-          }
-        })
-      const unionSchema = ast.createSchema({
-        type: 'union',
-        members: individualItems.map((item) => ast.createSchema({ type: 'ref', name: item.name })),
-      })
-      const unionType = renderSchemaType({ schema: unionSchema, name: dataName })
-      return (
-        <>
-          {individualItems.map((item) => item.rendered)}
-          {unionType}
-        </>
-      )
+      return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+        ...schema,
+        description: node.requestBody!.description ?? schema.description,
+      }))
     }
 
     const requestType = buildRequestType()
 
-    const responseTypes = node.responses.map((res) =>
-      renderSchemaType({
-        schema: res.content?.[0]?.schema ?? null,
+    const responseTypes = node.responses.map((res) => {
+      const variants = (res.content ?? []).filter((entry) => entry.schema)
+      // Multiple content types for a single status code — generate a union of the variants.
+      if (variants.length > 1) {
+        return buildContentTypeVariants(variants, resolver.resolveResponseStatusName(node, res.statusCode))
+      }
+      const primary = variants[0] ?? res.content?.[0]
+      return renderSchemaType({
+        schema: primary?.schema ?? null,
         name: resolver.resolveResponseStatusName(node, res.statusCode),
-        keysToOmit: res.content?.[0]?.keysToOmit,
-      }),
-    )
+        keysToOmit: primary?.keysToOmit,
+      })
+    })
 
     const dataType = renderSchemaType({
       schema: buildData({ ...node, parameters: params }, { resolver }),
@@ -250,23 +236,26 @@ export const typeGenerator = defineGenerator<PluginTs>({
     })
 
     function buildResponseType() {
-      if (!node.responses.some((res) => res.content?.[0]?.schema)) {
+      const hasSchema = (res: ast.ResponseNode) => (res.content ?? []).some((entry) => entry.schema)
+      if (!node.responses.some(hasSchema)) {
         return null
       }
 
       const responseName = resolver.resolveResponseName(node)
 
-      const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema)
+      const responsesWithSchema = node.responses.filter(hasSchema)
       const importedNames = new Set(
         responsesWithSchema.flatMap((res) =>
-          res.content?.[0]?.schema
-            ? adapter
-                .getImports(res.content[0].schema, (schemaName) => ({
-                  name: resolveImportName(schemaName),
-                  path: '',
-                }))
-                .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
-            : [],
+          (res.content ?? []).flatMap((entry) =>
+            entry.schema
+              ? adapter
+                  .getImports(entry.schema, (schemaName) => ({
+                    name: resolveImportName(schemaName),
+                    path: '',
+                  }))
+                  .flatMap((imp) => (Array.isArray(imp.name) ? imp.name : [imp.name]))
+              : [],
+          ),
         ),
       )
 

package/src/plugin.ts

@@ -1,5 +1,5 @@
-import { camelCase } from '@internals/utils'
-import { definePlugin, type Group } from '@kubb/core'
+import { createGroupConfig } from '@internals/shared'
+import { definePlugin } from '@kubb/core'
 import { typeGenerator } from './generators/typeGenerator.tsx'
 import { resolverTs } from './resolvers/resolverTs.ts'
 import type { PluginTs } from './types.ts'
@@ -54,17 +54,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     generators: userGenerators = [],
   } = options
 
-  const groupConfig = group
-    ? ({
-        ...group,
-        name: (ctx) => {
-          if (group.type === 'path') {
-            return `${ctx.group.split('/')[1]}`
-          }
-          return `${camelCase(ctx.group)}Controller`
-        },
-      } satisfies Group)
-    : null
+  const groupConfig = createGroupConfig(group, { suffix: 'Controller' })
 
   return {
     name: pluginTsName,

package/src/utils.ts

@@ -127,7 +127,7 @@ export function buildResponses(node: ast.OperationNode, { resolver }: BuildOpera
 }
 
 export function buildResponseUnion(node: ast.OperationNode, { resolver }: BuildOperationSchemaOptions): ast.SchemaNode | null {
-  const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema)
+  const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema))
 
   if (responsesWithSchema.length === 0) {
     return null