@kubb/plugin-ts 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/generators/utils.ts

@@ -0,0 +1,308 @@
+import { pascalCase } from '@internals/utils'
+import { createProperty, createSchema, narrowSchema, transform } from '@kubb/ast'
+import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import type { ResolverTs } from '../types.ts'
+
+type BuildParamsSchemaOptions = {
+  params: Array<ParameterNode>
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+/**
+ * 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, node, resolver }: BuildParamsSchemaOptions): SchemaNode {
+  return createSchema({
+    type: 'object',
+    properties: params.map((param) =>
+      createProperty({
+        name: param.name,
+        required: param.required,
+        schema: createSchema({
+          type: 'ref',
+          name: resolver.resolveParamName(node, param),
+        }),
+      }),
+    ),
+  })
+}
+
+type BuildOperationSchemaOptions = {
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+/**
+ * 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, resolver }: 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?.schema
+          ? createSchema({
+              type: 'ref',
+              name: resolver.resolveDataTypedName(node),
+              optional: true,
+            })
+          : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'pathParams',
+        required: pathParams.length > 0,
+        schema: pathParams.length > 0 ? buildParamsSchema({ params: pathParams, node, resolver }) : createSchema({ type: 'never' }),
+      }),
+      createProperty({
+        name: 'queryParams',
+        schema:
+          queryParams.length > 0
+            ? createSchema({ ...buildParamsSchema({ params: queryParams, node, resolver }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'headerParams',
+        schema:
+          headerParams.length > 0
+            ? createSchema({ ...buildParamsSchema({ params: headerParams, node, resolver }), optional: true })
+            : createSchema({ type: 'never', optional: true }),
+      }),
+      createProperty({
+        name: 'url',
+        required: true,
+        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, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  if (node.responses.length === 0) {
+    return null
+  }
+
+  return createSchema({
+    type: 'object',
+    properties: node.responses.map((res) =>
+      createProperty({
+        name: String(res.statusCode),
+        required: true,
+        schema: createSchema({
+          type: 'ref',
+          name: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+        }),
+      }),
+    ),
+  })
+}
+
+/**
+ * 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, resolver }: 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: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+      }),
+    ),
+  })
+}
+
+type BuildGroupedParamsSchemaOptions = {
+  params: Array<ParameterNode>
+  /**
+   * Parent type name (e.g. `FindPetsByStatusQueryParams`) used to derive enum names
+   * for inline enum properties (e.g. `FindPetsByStatusQueryParamsStatusEnum`).
+   */
+  parentName?: string
+}
+
+/**
+ * Builds an `ObjectSchemaNode` for a grouped parameters type (path/query/header) in legacy mode.
+ * Each property directly embeds the parameter's schema inline (not a ref).
+ * Used to generate `<OperationId>PathParams`, `<OperationId>QueryParams`, `<OperationId>HeaderParams`.
+ * @deprecated Legacy only — will be removed in v6.
+ */
+export function buildGroupedParamsSchema({ params, parentName }: BuildGroupedParamsSchemaOptions): SchemaNode {
+  return createSchema({
+    type: 'object',
+    properties: params.map((param) => {
+      let schema = param.schema
+      if (narrowSchema(schema, 'enum') && !schema.name && parentName) {
+        schema = { ...schema, name: pascalCase([parentName, param.name, 'enum'].join(' ')) }
+      }
+      return createProperty({
+        name: param.name,
+        required: param.required,
+        schema,
+      })
+    }),
+  })
+}
+
+/**
+ * Builds the legacy wrapper `ObjectSchemaNode` for `<OperationId>Mutation` / `<OperationId>Query`.
+ * Structure: `{ Response, Request?, QueryParams?, PathParams?, HeaderParams?, Errors }`.
+ * Mirrors the v4 naming convention where this type acts as a namespace for the operation's shapes.
+ *
+ * @deprecated Legacy only — will be removed in v6.
+ */
+export function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+  const isGet = node.method.toLowerCase() === 'get'
+  const successResponses = node.responses.filter((res) => {
+    const code = Number(res.statusCode)
+    return !Number.isNaN(code) && code >= 200 && code < 300
+  })
+  const errorResponses = node.responses.filter((res) => res.statusCode === 'default' || Number(res.statusCode) >= 400)
+
+  const responseSchema =
+    successResponses.length > 0
+      ? successResponses.length === 1
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, successResponses[0]!.statusCode) })
+        : createSchema({
+            type: 'union',
+            members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+          })
+      : createSchema({ type: 'any' })
+
+  const errorsSchema =
+    errorResponses.length > 0
+      ? errorResponses.length === 1
+        ? createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, errorResponses[0]!.statusCode) })
+        : createSchema({
+            type: 'union',
+            members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+          })
+      : createSchema({ type: 'any' })
+
+  const properties = [createProperty({ name: 'Response', required: true, schema: responseSchema })]
+
+  if (!isGet && node.requestBody?.schema) {
+    properties.push(
+      createProperty({
+        name: 'Request',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveDataTypedName(node) }),
+      }),
+    )
+  }
+
+  if (node.parameters.some((p) => p.in === 'query') && resolver.resolveQueryParamsTypedName) {
+    properties.push(
+      createProperty({
+        name: 'QueryParams',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveQueryParamsTypedName(node) }),
+      }),
+    )
+  }
+
+  if (node.parameters.some((p) => p.in === 'path') && resolver.resolvePathParamsTypedName) {
+    properties.push(
+      createProperty({
+        name: 'PathParams',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolvePathParamsTypedName(node) }),
+      }),
+    )
+  }
+
+  if (node.parameters.some((p) => p.in === 'header') && resolver.resolveHeaderParamsTypedName) {
+    properties.push(
+      createProperty({
+        name: 'HeaderParams',
+        required: true,
+        schema: createSchema({ type: 'ref', name: resolver.resolveHeaderParamsTypedName(node) }),
+      }),
+    )
+  }
+
+  properties.push(createProperty({ name: 'Errors', required: true, schema: errorsSchema }))
+
+  return createSchema({ type: 'object', properties })
+}
+
+/**
+ * Builds the legacy response union for `<OperationId>MutationResponse` / `<OperationId>QueryResponse`.
+ * In legacy mode this is the **success** response only (not the full union including errors).
+ * Returns an `any` schema when there is no success response, matching v4 behavior.
+ * @deprecated Legacy only — will be removed in v6.
+ */
+export function buildLegacyResponseUnionSchemaNode({ node, resolver }: BuildOperationSchemaOptions): SchemaNode {
+  const successResponses = node.responses.filter((res) => {
+    const code = Number(res.statusCode)
+    return !Number.isNaN(code) && code >= 200 && code < 300
+  })
+
+  if (successResponses.length === 0) {
+    return createSchema({ type: 'any' })
+  }
+
+  if (successResponses.length === 1) {
+    return createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, successResponses[0]!.statusCode) })
+  }
+
+  return createSchema({
+    type: 'union',
+    members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusTypedName(node, res.statusCode) })),
+  })
+}
+
+/**
+ * Names unnamed enum nodes within a schema tree based on the parent type name.
+ * Used in legacy mode to ensure inline enums in response/request schemas get
+ * extracted as named enum declarations (e.g. `DeletePet200Enum`).
+ *
+ * @deprecated Legacy only — will be removed in v6.
+ */
+export function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
+  return transform(node, {
+    schema(n) {
+      const enumNode = narrowSchema(n, 'enum')
+      if (enumNode && !enumNode.name) {
+        return { ...enumNode, name: pascalCase([parentName, 'enum'].join(' ')) }
+      }
+      return undefined
+    },
+    property(p) {
+      const enumNode = narrowSchema(p.schema, 'enum')
+      if (enumNode && !enumNode.name) {
+        return {
+          ...p,
+          schema: { ...enumNode, name: pascalCase([parentName, p.name, 'enum'].join(' ')) },
+        }
+      }
+      return undefined
+    },
+  })
+}

package/src/index.ts

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

package/src/plugin.ts

@@ -1,14 +1,14 @@
 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 { typeGenerator } from './generators/index.ts'
+import { getPreset } from './presets.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,
@@ -17,47 +17,40 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
     override = [],
     enumType = 'asConst',
     enumKeyCasing = 'none',
-    enumSuffix = 'enum',
-    dateType = 'string',
-    integerType = 'number',
-    unknownType = 'any',
     optionalType = 'questionToken',
     arrayType = 'array',
-    emptySchemaType = unknownType,
     syntaxType = 'type',
-    transformers = {},
-    mapper = {},
     paramsCasing,
     generators = [typeGenerator].filter(Boolean),
-    contentType,
-    UNSTABLE_NAMING,
+    compatibilityPreset = 'default',
+    resolvers: userResolvers,
+    transformers: userTransformers = [],
   } = options
 
-  // @deprecated Will be removed in v5 when collisionDetection defaults to true
-  const usedEnumNames = {}
+  const { baseResolver, resolver, transformers } = getPreset(compatibilityPreset, {
+    resolvers: userResolvers,
+    transformers: userTransformers,
+  })
+
+  let resolveNameWarning = false
 
   return {
     name: pluginTsName,
     options: {
       output,
-      transformers,
-      dateType,
-      integerType,
       optionalType,
       arrayType,
       enumType,
       enumKeyCasing,
-      enumSuffix,
-      unknownType,
-      emptySchemaType,
       syntaxType,
       group,
       override,
-      mapper,
       paramsCasing,
-      usedEnumNames,
+      compatibilityPreset,
+      baseResolver,
+      resolver,
+      transformers,
     },
-    pre: [pluginOasName],
     resolvePath(baseName, pathMode, options) {
       const root = path.resolve(this.config.root, this.config.output.path)
       const mode = pathMode ?? getMode(path.resolve(root, output.path))
@@ -93,83 +86,77 @@ export const pluginTs = definePlugin<PluginTs>((options) => {
       return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
-      const resolvedName = pascalCase(name, { isFile: type === 'file' })
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
+      if (!resolveNameWarning) {
+        this.driver.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs instead')
+        resolveNameWarning = true
       }
 
-      return resolvedName
+      return resolver.default(name, type)
     },
     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 })
-
-        await walk(
-          this.rootNode,
-          {
-            async schema(schemaNode) {
-              const writeTasks = generators.map(async (generator) => {
-                if (generator.type === 'react' && generator.version === '2') {
-                  await buildSchema(schemaNode, {
-                    config,
-                    fabric,
-                    Component: generator.Schema,
-                    plugin,
-                    version: generator.version,
-                  })
-                }
+      if (!adapter) {
+        throw new Error('Plugin cannot work without adapter being set')
+      }
+
+      await openInStudio({ ast: true })
+
+      await walk(rootNode, {
+        depth: 'shallow',
+        async schema(schemaNode) {
+          const writeTasks = generators.map(async (generator) => {
+            if (generator.type === 'react' && generator.version === '2') {
+              const options = resolver.resolveOptions(schemaNode, { options: plugin.options, exclude, include, override })
+
+              if (options === null) {
+                return
+              }
+
+              await renderSchema(schemaNode, {
+                options,
+                adapter,
+                config,
+                fabric,
+                Component: generator.Schema,
+                plugin,
+                driver,
+                mode,
               })
+            }
+          })
 
-              await writeTasks
-            },
-          },
-          { depth: 'shallow' },
-        )
+          await Promise.all(writeTasks)
+        },
+        async operation(operationNode) {
+          const writeTasks = generators.map(async (generator) => {
+            if (generator.type === 'react' && generator.version === '2') {
+              const options = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
 
-        return
-      }
+              if (options === null) {
+                return
+              }
 
-      const oas = await this.getOas()
-
-      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        pluginManager: this.pluginManager,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        include: undefined,
-        override,
-        mode,
-        output: output.path,
-      })
+              await renderOperation(operationNode, {
+                options,
+                adapter,
+                config,
+                fabric,
+                Component: generator.Operation,
+                plugin,
+                driver,
+                mode,
+              })
+            }
+          })
 
-      const schemaFiles = await schemaGenerator.build(...generators)
-      await this.upsertFile(...schemaFiles)
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        pluginManager: this.pluginManager,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-        UNSTABLE_NAMING,
+          await Promise.all(writeTasks)
+        },
       })
 
-      const operationFiles = await operationGenerator.build(...generators)
-      await this.upsertFile(...operationFiles)
-
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
         type: output.barrelType ?? 'named',
         root,

package/src/presets.ts

@@ -0,0 +1,23 @@
+import type { Visitor } from '@kubb/ast/types'
+import { type CompatibilityPreset, definePreset, definePresets, getPreset as getCorePreset } from '@kubb/core'
+import { resolverTs, resolverTsLegacy } from './resolvers/index.ts'
+import type { ResolverTs } from './types.ts'
+
+export const presets = definePresets<ResolverTs>({
+  default: definePreset('default', { resolvers: [resolverTs] }),
+  kubbV4: definePreset('kubbV4', { resolvers: [resolverTsLegacy] }),
+})
+
+type GetPresetOptions = {
+  resolvers?: Array<ResolverTs>
+  transformers?: Array<Visitor>
+}
+
+export function getPreset(preset: CompatibilityPreset, { resolvers, transformers }: GetPresetOptions = {}) {
+  return getCorePreset({
+    preset,
+    presets,
+    resolvers: [resolverTs, ...(resolvers ?? [])],
+    transformers,
+  })
+}