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

package/src/{resolverTs.ts → resolvers/resolverTs.ts}

@@ -1,6 +1,10 @@
 import { pascalCase } from '@internals/utils'
 import { defineResolver } from '@kubb/core'
-import type { PluginTs } from './types.ts'
+import type { PluginTs } from '../types.ts'
+
+function resolveName(name: string, type?: 'file' | 'function' | 'type' | 'const'): string {
+  return pascalCase(name, { isFile: type === 'file' })
+}
 
 /**
  * Resolver for `@kubb/plugin-ts` that provides the default naming and path-resolution
@@ -23,7 +27,7 @@ import type { PluginTs } from './types.ts'
 export const resolverTs = defineResolver<PluginTs>(() => {
   return {
     default(name, type) {
-      return pascalCase(name, { isFile: type === 'file' })
+      return resolveName(name, type)
     },
     resolveName(name) {
       return this.default(name, 'function')
@@ -73,5 +77,25 @@ export const resolverTs = defineResolver<PluginTs>(() => {
     resolveEnumKeyTypedName(node) {
       return `${this.resolveTypedName(node.name ?? '')}Key`
     },
+    resolvePathParamsName(_node) {
+      throw new Error('resolvePathParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.')
+    },
+    resolvePathParamsTypedName(_node) {
+      throw new Error('resolvePathParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.')
+    },
+    resolveQueryParamsName(node) {
+      return this.resolveName(`${node.operationId} QueryParams`)
+    },
+    resolveQueryParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} QueryParams`)
+    },
+    resolveHeaderParamsName(_node) {
+      throw new Error('resolveHeaderParamsName is only available in legacy mode (legacy: true). Use resolveParamName per individual parameter instead.')
+    },
+    resolveHeaderParamsTypedName(_node) {
+      throw new Error(
+        'resolveHeaderParamsTypedName is only available in legacy mode (legacy: true). Use resolveParamTypedName per individual parameter instead.',
+      )
+    },
   }
 })

package/src/resolvers/resolverTsLegacy.ts

@@ -0,0 +1,85 @@
+import { defineResolver } from '@kubb/core'
+import type { PluginTs } from '../types.ts'
+import { resolverTs } from './resolverTs.ts'
+
+/**
+ * Legacy resolver for `@kubb/plugin-ts` that reproduces the naming conventions
+ * used before the v2 resolver refactor. Enable via `legacy: true` in plugin options.
+ *
+ * Key differences from the default resolver:
+ * - Response status types: `<OperationId><StatusCode>` (e.g. `CreatePets201`) instead of `<OperationId>Status201`
+ * - Default/error responses: `<OperationId>Error` instead of `<OperationId>StatusDefault`
+ * - Request body: `<OperationId>MutationRequest` (non-GET) / `<OperationId>QueryRequest` (GET)
+ * - Combined responses type: `<OperationId>Mutation` / `<OperationId>Query`
+ * - Response union: `<OperationId>MutationResponse` / `<OperationId>QueryResponse`
+ *
+ * @example
+ * ```ts
+ * import { resolverTsLegacy } from '@kubb/plugin-ts'
+ *
+ * resolverTsLegacy.resolveResponseStatusTypedName(node, 201)  // → 'CreatePets201'
+ * resolverTsLegacy.resolveResponseStatusTypedName(node, 'default')  // → 'CreatePetsError'
+ * resolverTsLegacy.resolveDataTypedName(node)  // → 'CreatePetsMutationRequest' (POST)
+ * resolverTsLegacy.resolveResponsesTypedName(node)  // → 'CreatePetsMutation' (POST)
+ * resolverTsLegacy.resolveResponseTypedName(node)  // → 'CreatePetsMutationResponse' (POST)
+ * ```
+ */
+export const resolverTsLegacy = defineResolver<PluginTs>(() => {
+  return {
+    ...resolverTs,
+    resolveResponseStatusName(node, statusCode) {
+      if (statusCode === 'default') {
+        return this.resolveName(`${node.operationId} Error`)
+      }
+      return this.resolveName(`${node.operationId} ${statusCode}`)
+    },
+    resolveResponseStatusTypedName(node, statusCode) {
+      if (statusCode === 'default') {
+        return this.resolveTypedName(`${node.operationId} Error`)
+      }
+      return this.resolveTypedName(`${node.operationId} ${statusCode}`)
+    },
+    resolveDataName(node) {
+      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
+      return this.resolveName(`${node.operationId} ${suffix}`)
+    },
+    resolveDataTypedName(node) {
+      const suffix = node.method === 'GET' ? 'QueryRequest' : 'MutationRequest'
+      return this.resolveTypedName(`${node.operationId} ${suffix}`)
+    },
+    resolveResponsesName(node) {
+      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
+      return `${this.default(node.operationId, 'function')}${suffix}`
+    },
+    resolveResponsesTypedName(node) {
+      const suffix = node.method === 'GET' ? 'Query' : 'Mutation'
+      return `${this.default(node.operationId, 'type')}${suffix}`
+    },
+    resolveResponseName(node) {
+      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
+      return this.resolveName(`${node.operationId} ${suffix}`)
+    },
+    resolveResponseTypedName(node) {
+      const suffix = node.method === 'GET' ? 'QueryResponse' : 'MutationResponse'
+      return this.resolveTypedName(`${node.operationId} ${suffix}`)
+    },
+    resolvePathParamsName(node) {
+      return this.resolveName(`${node.operationId} PathParams`)
+    },
+    resolvePathParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} PathParams`)
+    },
+    resolveQueryParamsName(node) {
+      return this.resolveName(`${node.operationId} QueryParams`)
+    },
+    resolveQueryParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} QueryParams`)
+    },
+    resolveHeaderParamsName(node) {
+      return this.resolveName(`${node.operationId} HeaderParams`)
+    },
+    resolveHeaderParamsTypedName(node) {
+      return this.resolveTypedName(`${node.operationId} HeaderParams`)
+    },
+  }
+})

package/src/types.ts

@@ -9,7 +9,7 @@ import type { Generator } from '@kubb/plugin-oas/generators'
  * Extends the base `Resolver` (which provides `default` and `resolveOptions`) with
  * plugin-specific naming helpers for operations, parameters, responses, and schemas.
  */
-type ResolverTs = Resolver & {
+export type ResolverTs = Resolver & {
   /**
    * Resolves the variable/function name for a given raw name (equivalent to `default(name, 'function')`).
    * Use this shorthand when matching the `name` field produced by the v2 TypeGenerator,
@@ -133,6 +133,60 @@ type ResolverTs = Resolver & {
    * resolver.resolveEnumKeyTypedName(node) // → 'PetStatusKey'
    */
   resolveEnumKeyTypedName(node: SchemaNode): string
+  /**
+   * Resolves the variable/function name for an operation's grouped path parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamName` per individual parameter instead.
+   * @example
+   * resolver.resolvePathParamsName(node) // → 'GetPetByIdPathParams'
+   */
+  resolvePathParamsName?(node: OperationNode): string
+  /**
+   * Resolves the TypeScript type alias name for an operation's grouped path parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamTypedName` per individual parameter instead.
+   * @example
+   * resolver.resolvePathParamsTypedName(node) // → 'GetPetByIdPathParams'
+   */
+  resolvePathParamsTypedName?(node: OperationNode): string
+  /**
+   * Resolves the variable/function name for an operation's grouped query parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamName` per individual parameter instead.
+   * @example
+   * resolver.resolveQueryParamsName(node) // → 'FindPetsByStatusQueryParams'
+   */
+  resolveQueryParamsName?(node: OperationNode): string
+  /**
+   * Resolves the TypeScript type alias name for an operation's grouped query parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamTypedName` per individual parameter instead.
+   * @example
+   * resolver.resolveQueryParamsTypedName(node) // → 'FindPetsByStatusQueryParams'
+   */
+  resolveQueryParamsTypedName?(node: OperationNode): string
+  /**
+   * Resolves the variable/function name for an operation's grouped header parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamName` per individual parameter instead.
+   * @example
+   * resolver.resolveHeaderParamsName(node) // → 'DeletePetHeaderParams'
+   */
+  resolveHeaderParamsName?(node: OperationNode): string
+  /**
+   * Resolves the TypeScript type alias name for an operation's grouped header parameters type.
+   * Only available in legacy mode (`legacy: true`).
+   *
+   * @deprecated Legacy only — will be removed in v6. Use `resolveParamTypedName` per individual parameter instead.
+   * @example
+   * resolver.resolveHeaderParamsTypedName(node) // → 'DeletePetHeaderParams'
+   */
+  resolveHeaderParamsTypedName?(node: OperationNode): string
 }
 
 export type Options = {
@@ -191,52 +245,6 @@ export type Options = {
    * @default 'type'
    */
   syntaxType?: 'type' | 'interface'
-  /**
-   * Set a suffix for the generated enums.
-   * @default 'enum'
-   * @deprecated Set `enumSuffix` on the adapter (`adapterOas({ enumSuffix })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  enumSuffix?: string
-  /**
-   * Choose to use date or datetime as JavaScript Date instead of string.
-   * - 'string' represents dates as string values.
-   * - 'date' represents dates as JavaScript Date objects.
-   * @default 'string'
-   * @deprecated Set `dateType` on the adapter (`adapterOas({ dateType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  dateType?: 'string' | 'date'
-  /**
-   * Choose to use `number` or `bigint` for integer fields with `int64` format.
-   * - 'number' uses the TypeScript `number` type (matches JSON.parse() runtime behavior).
-   * - 'bigint' uses the TypeScript `bigint` type (accurate for values exceeding Number.MAX_SAFE_INTEGER).
-   * @note in v5 of Kubb 'bigint' will become the default to better align with OpenAPI's int64 specification.
-   * @default 'number'
-   * @deprecated Set `integerType` on the adapter (`adapterOas({ integerType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  integerType?: 'number' | 'bigint'
-  /**
-   * Which type to use when the Swagger/OpenAPI file is not providing more information.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default 'any'
-   * @deprecated Set `unknownType` on the adapter (`adapterOas({ unknownType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  unknownType?: 'any' | 'unknown' | 'void'
-  /**
-   * Which type to use for empty schema values.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default `unknownType`
-   * @deprecated Set `emptySchemaType` on the adapter (`adapterOas({ emptySchemaType })`) instead.
-   * In v5, the adapter owns this decision at parse time; the plugin option is ignored.
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void'
   /**
    * Choose what to use as mode for an optional value.
    * - 'questionToken' marks the property as optional with ? (e.g., type?: string).
@@ -273,6 +281,17 @@ export type Options = {
    * Unstable naming for v5
    */
   UNSTABLE_NAMING?: true
+  /**
+   * Enable legacy naming conventions for backwards compatibility.
+   * When enabled, operation-level types use the old naming scheme:
+   * - GET responses → `<OperationId>QueryResponse`, `<OperationId>Query`
+   * - Non-GET responses → `<OperationId>MutationResponse`, `<OperationId>Mutation`
+   * - Request body → `<OperationId>QueryRequest` / `<OperationId>MutationRequest`
+   * - Response status codes → `<OperationId><StatusCode>` (e.g. `CreatePets201`)
+   * - Default/error response → `<OperationId>Error`
+   * @default false
+   */
+  legacy?: boolean
 }
 
 type ResolvedOptions = {
@@ -281,16 +300,20 @@ type ResolvedOptions = {
   override: NonNullable<Options['override']>
   enumType: NonNullable<Options['enumType']>
   enumKeyCasing: NonNullable<Options['enumKeyCasing']>
-  enumSuffix: NonNullable<Options['enumSuffix']>
-  dateType: NonNullable<Options['dateType']>
-  integerType: NonNullable<Options['integerType']>
-  unknownType: NonNullable<Options['unknownType']>
-  emptySchemaType: NonNullable<Options['emptySchemaType']>
   optionalType: NonNullable<Options['optionalType']>
   arrayType: NonNullable<Options['arrayType']>
   transformers: NonNullable<Options['transformers']>
   syntaxType: NonNullable<Options['syntaxType']>
   paramsCasing: Options['paramsCasing']
+  legacy: NonNullable<Options['legacy']>
+  resolver: ResolverTs
+  /**
+   * The base resolver without any `transformers.name` wrapping.
+   * Used internally to derive enum prefix names so that user-defined
+   * name transformations (e.g. appending `Type`) are not embedded in
+   * the middle of inline-enum identifiers.
+   */
+  baseResolver?: ResolverTs
 }
 
 export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>