@kubb/plugin-ts 5.0.0-alpha.1 → 5.0.0-alpha.11

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',
+    deprecated: node.deprecated,
+    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:`).
+ * All responses are included; those without a schema are represented as a ref to a `never` type.
+ */
+export function buildResponsesSchemaNode({ node, resolveName }: BuildOperationSchemaOptions): SchemaNode | null {
+  if (node.responses.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'object',
+    properties: node.responses.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/index.ts

@@ -1,2 +1,3 @@
 export { pluginTs, pluginTsName } from './plugin.ts'
+export { resolverTs } from './resolverTs.ts'
 export type { PluginTs } from './types.ts'

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

@@ -1,14 +1,15 @@
 import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
+import { camelCase } from '@internals/utils'
 import { walk } from '@kubb/ast'
-import { definePlugin, type Group, getBarrelFiles, getMode } from '@kubb/core'
-import { buildSchema, OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
-import { typeGenerator } from './generators'
+import { createPlugin, type Group, getBarrelFiles, getMode, renderOperation, renderSchema } from '@kubb/core'
+import { OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
+import { typeGenerator, typeGeneratorV2 } from './generators'
+import { resolverTs } from './resolverTs.ts'
 import type { PluginTs } from './types.ts'
 
 export const pluginTsName = 'plugin-ts' satisfies PluginTs['name']
 
-export const pluginTs = definePlugin<PluginTs>((options) => {
+export const pluginTs = createPlugin<PluginTs>((options) => {
   const {
     output = { path: 'types', barrelType: 'named' },
     group,
@@ -26,9 +27,8 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     emptySchemaType = unknownType,
     syntaxType = 'type',
     transformers = {},
-    mapper = {},
     paramsCasing,
-    generators = [typeGenerator].filter(Boolean),
+    generators = [typeGenerator, typeGeneratorV2].filter(Boolean),
     contentType,
     UNSTABLE_NAMING,
   } = options
@@ -53,7 +53,6 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       syntaxType,
       group,
       override,
-      mapper,
       paramsCasing,
       usedEnumNames,
     },
@@ -93,7 +92,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
-      const resolvedName = pascalCase(name, { isFile: type === 'file' })
+      const resolvedName = resolverTs.default(name, type)
 
       if (type) {
         return transformers?.name?.(resolvedName, type) || resolvedName
@@ -102,45 +101,91 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       return resolvedName
     },
     async install() {
-      const { config, fabric, plugin } = 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))
 
-      if (this.rootNode) {
-        await this.openInStudio({ ast: true })
+      if (adapter) {
+        await openInStudio({ ast: true })
 
         await walk(
-          this.rootNode,
+          rootNode,
           {
             async schema(schemaNode) {
               const writeTasks = generators.map(async (generator) => {
                 if (generator.type === 'react' && generator.version === '2') {
-                  await buildSchema(schemaNode, {
+                  const options = resolverTs.resolveOptions(schemaNode, { options: plugin.options, exclude, include, override })
+
+                  if (options === null) {
+                    return
+                  }
+
+                  await renderSchema(schemaNode, {
+                    options,
+                    adapter,
                     config,
                     fabric,
                     Component: generator.Schema,
                     plugin,
-                    version: generator.version,
+                    driver,
+                    mode,
                   })
                 }
               })
 
-              await writeTasks
+              await Promise.all(writeTasks)
+            },
+            async operation(operationNode) {
+              const writeTasks = generators.map(async (generator) => {
+                if (generator.type === 'react' && generator.version === '2') {
+                  const options = resolverTs.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
+
+                  if (options === null) {
+                    return
+                  }
+
+                  await renderOperation(operationNode, {
+                    options,
+                    adapter,
+                    config,
+                    fabric,
+                    Component: generator.Operation,
+                    plugin,
+                    driver,
+                    mode,
+                  })
+                }
+              })
+
+              await Promise.all(writeTasks)
             },
           },
           { 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
       }
 
+      // v1 flow
+
       const oas = await this.getOas()
 
       const schemaGenerator = new SchemaGenerator(this.plugin.options, {
         fabric: this.fabric,
         oas,
-        pluginManager: this.pluginManager,
+        driver: this.driver,
         events: this.events,
         plugin: this.plugin,
         contentType,
@@ -156,7 +201,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,
@@ -175,7 +220,7 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
         root,
         output,
         meta: {
-          pluginKey: this.plugin.key,
+          pluginName: this.plugin.name,
         },
       })