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

package/src/generators/typeGeneratorLegacy.tsx

@@ -0,0 +1,345 @@
+import path from 'node:path'
+import { pascalCase } from '@internals/utils'
+import { caseParams, composeTransformers, createProperty, createSchema, narrowSchema, schemaTypes, transform } from '@kubb/ast'
+import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import { defineGenerator, getMode } from '@kubb/core'
+import { File } from '@kubb/react-fabric'
+import { Type } from '../components/Type.tsx'
+import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
+import { resolverTsLegacy } from '../resolvers/resolverTsLegacy.ts'
+import type { PluginTs, ResolverTs } from '../types'
+
+type BuildGroupedParamsSchemaOptions = {
+  params: Array<ParameterNode>
+  parentName?: string
+}
+
+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,
+      })
+    }),
+  })
+}
+
+type BuildOperationSchemaOptions = {
+  node: OperationNode
+  resolver: ResolverTs
+}
+
+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 })
+}
+
+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) })),
+  })
+}
+
+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
+    },
+  })
+}
+
+export const typeGeneratorLegacy = defineGenerator<PluginTs>({
+  name: 'typescript-legacy',
+  type: 'react',
+  Operation({ node, adapter, options, config }) {
+    const { enumType, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, resolver, transformers = [] } = options
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+
+    const file = resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group })
+    const params = caseParams(node.parameters, paramsCasing)
+
+    function renderSchemaType({
+      node: schemaNode,
+      name,
+      typedName,
+      description,
+      keysToOmit,
+    }: {
+      node: SchemaNode | null
+      name: string
+      typedName: string
+      description?: string
+      keysToOmit?: Array<string>
+    }) {
+      if (!schemaNode) {
+        return null
+      }
+
+      const transformedNode = transform(schemaNode, composeTransformers(...transformers))
+
+      const imports = adapter.getImports(transformedNode, (schemaName) => ({
+        name: resolver.default(schemaName, 'type'),
+        path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).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}
+            node={transformedNode}
+            description={description}
+            enumType={enumType}
+            enumKeyCasing={enumKeyCasing}
+            optionalType={optionalType}
+            arrayType={arrayType}
+            syntaxType={syntaxType}
+            resolver={resolver}
+            keysToOmit={keysToOmit}
+          />
+        </>
+      )
+    }
+
+    const pathParams = params.filter((p) => p.in === 'path')
+    const queryParams = params.filter((p) => p.in === 'query')
+    const headerParams = params.filter((p) => p.in === 'header')
+
+    const responseTypes = node.responses.map((res) => {
+      const responseName = resolver.resolveResponseStatusName(node, res.statusCode)
+      const baseResponseName = resolverTsLegacy.resolveResponseStatusName(node, res.statusCode)
+
+      return renderSchemaType({
+        node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
+        name: responseName,
+        typedName: resolver.resolveResponseStatusTypedName(node, res.statusCode),
+        description: res.description,
+        keysToOmit: res.keysToOmit,
+      })
+    })
+
+    const requestType = node.requestBody?.schema
+      ? renderSchemaType({
+          node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
+          name: resolver.resolveDataName(node),
+          typedName: resolver.resolveDataTypedName(node),
+          description: node.requestBody.description ?? node.requestBody.schema.description,
+          keysToOmit: node.requestBody.keysToOmit,
+        })
+      : null
+
+    const legacyParamTypes = [
+      pathParams.length > 0
+        ? renderSchemaType({
+            node: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName!(node) }),
+            name: resolver.resolvePathParamsName!(node),
+            typedName: resolver.resolvePathParamsTypedName!(node),
+          })
+        : null,
+      queryParams.length > 0
+        ? renderSchemaType({
+            node: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName!(node) }),
+            name: resolver.resolveQueryParamsName!(node),
+            typedName: resolver.resolveQueryParamsTypedName!(node),
+          })
+        : null,
+      headerParams.length > 0
+        ? renderSchemaType({
+            node: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName!(node) }),
+            name: resolver.resolveHeaderParamsName!(node),
+            typedName: resolver.resolveHeaderParamsTypedName!(node),
+          })
+        : null,
+    ]
+
+    const legacyResponsesType = renderSchemaType({
+      node: buildLegacyResponsesSchemaNode({ node, resolver }),
+      name: resolver.resolveResponsesName(node),
+      typedName: resolver.resolveResponsesTypedName(node),
+    })
+
+    const legacyResponseType = renderSchemaType({
+      node: buildLegacyResponseUnionSchemaNode({ node, resolver }),
+      name: resolver.resolveResponseName(node),
+      typedName: resolver.resolveResponseTypedName(node),
+    })
+
+    return (
+      <File
+        baseName={file.baseName}
+        path={file.path}
+        meta={file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
+        {legacyParamTypes}
+        {responseTypes}
+        {requestType}
+        {legacyResponseType}
+        {legacyResponsesType}
+      </File>
+    )
+  },
+  Schema({ node, adapter, options, config }) {
+    const { enumType, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, resolver, transformers = [] } = options
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+
+    if (!node.name) {
+      return
+    }
+
+    const transformedNode = transform(node, composeTransformers(...transformers))
+
+    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+      name: resolver.default(schemaName, 'type'),
+      path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
+    }))
+
+    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
+
+    const typedName = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyTypedName(node) : resolver.resolveTypedName(node.name)
+
+    const type = {
+      name: resolver.resolveName(node.name),
+      typedName,
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
+    } as const
+
+    return (
+      <File
+        baseName={type.file.baseName}
+        path={type.file.path}
+        meta={type.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
+        {mode === 'split' &&
+          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}
+          node={transformedNode}
+          enumType={enumType}
+          enumKeyCasing={enumKeyCasing}
+          optionalType={optionalType}
+          arrayType={arrayType}
+          syntaxType={syntaxType}
+          resolver={resolver}
+        />
+      </File>
+    )
+  },
+})

package/src/index.ts

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

package/src/plugin.ts

@@ -1,8 +1,6 @@
 import path from 'node:path'
-import { camelCase } from '@internals/utils'
 import { walk } from '@kubb/ast'
-import { createPlugin, type Group, getBarrelFiles, getMode, renderOperation, renderSchema } from '@kubb/core'
-import { typeGenerator } from './generators/index.ts'
+import { createPlugin, getBarrelFiles, renderOperation, renderSchema } from '@kubb/core'
 import { getPreset } from './presets.ts'
 import type { PluginTs } from './types.ts'
 
@@ -21,73 +19,49 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     arrayType = 'array',
     syntaxType = 'type',
     paramsCasing,
-    generators = [typeGenerator].filter(Boolean),
     compatibilityPreset = 'default',
-    resolvers: userResolvers,
+    resolvers: userResolvers = [],
     transformers: userTransformers = [],
+    generators: userGenerators = [],
   } = options
 
-  const { baseResolver, resolver, transformers } = getPreset(compatibilityPreset, {
+  const { resolver, transformers, generators } = getPreset(compatibilityPreset, {
     resolvers: userResolvers,
     transformers: userTransformers,
+    generators: userGenerators,
   })
 
   let resolveNameWarning = false
+  let resolvePathWarning = false
 
   return {
     name: pluginTsName,
     options: {
       output,
       optionalType,
+      group,
       arrayType,
       enumType,
       enumKeyCasing,
       syntaxType,
-      group,
-      override,
       paramsCasing,
-      compatibilityPreset,
-      baseResolver,
       resolver,
       transformers,
     },
     resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
-          ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Controller`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
+      if (!resolvePathWarning) {
+        this.driver.events.emit('warn', 'Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
+        resolvePathWarning = true
       }
 
-      return path.resolve(root, output.path, baseName)
+      return resolver.resolvePath(
+        { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
+        { root: path.resolve(this.config.root, this.config.output.path), output, group },
+      )
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.driver.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs instead')
+        this.driver.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs.default instead')
         resolveNameWarning = true
       }
 
@@ -97,7 +71,6 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
       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 (!adapter) {
         throw new Error('Plugin cannot work without adapter being set')
@@ -124,7 +97,6 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
                 Component: generator.Schema,
                 plugin,
                 driver,
-                mode,
               })
             }
           })
@@ -148,7 +120,6 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
                 Component: generator.Operation,
                 plugin,
                 driver,
-                mode,
               })
             }
           })

package/src/presets.ts

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

package/src/printers/index.ts

@@ -0,0 +1 @@
+export { printerTs } from './printerTs.ts'

package/src/{printer.ts → printers/printerTs.ts}

@@ -3,10 +3,11 @@ import { isStringType, narrowSchema, schemaTypes } from '@kubb/ast'
 import type { ArraySchemaNode, SchemaNode } from '@kubb/ast/types'
 import type { PrinterFactoryOptions } from '@kubb/core'
 import { definePrinter } from '@kubb/core'
+import { safePrint } from '@kubb/fabric-core/parsers/typescript'
 import type ts from 'typescript'
-import { ENUM_TYPES_WITH_KEY_SUFFIX, OPTIONAL_ADDS_QUESTION_TOKEN, OPTIONAL_ADDS_UNDEFINED } from './constants.ts'
-import * as factory from './factory.ts'
-import type { PluginTs, ResolverTs } from './types.ts'
+import { ENUM_TYPES_WITH_KEY_SUFFIX, OPTIONAL_ADDS_QUESTION_TOKEN, OPTIONAL_ADDS_UNDEFINED } from '../constants.ts'
+import * as factory from '../factory.ts'
+import type { PluginTs, ResolverTs } from '../types.ts'
 
 type TsOptions = {
   /**
@@ -50,7 +51,7 @@ type TsOptions = {
 /**
  * TypeScript printer factory options: maps `SchemaNode` → `ts.TypeNode` (raw) or `ts.Node` (full declaration).
  */
-type TsPrinter = PrinterFactoryOptions<'typescript', TsOptions, ts.TypeNode, ts.Node>
+type TsPrinter = PrinterFactoryOptions<'typescript', TsOptions, ts.TypeNode, string>
 
 /**
  * Converts a primitive const value to a TypeScript literal type node.
@@ -287,32 +288,33 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
                 })
               }
 
-              return this.print(m)
+              return this.transform(m)
             })
             .filter(Boolean)
 
           return factory.createUnionDeclaration({ withParentheses: true, nodes: memberNodes }) ?? undefined
         }
 
-        return factory.createUnionDeclaration({ withParentheses: true, nodes: buildMemberNodes(members, this.print) }) ?? undefined
+        return factory.createUnionDeclaration({ withParentheses: true, nodes: buildMemberNodes(members, this.transform) }) ?? undefined
       },
       intersection(node) {
-        return factory.createIntersectionDeclaration({ withParentheses: true, nodes: buildMemberNodes(node.members, this.print) }) ?? undefined
+        return factory.createIntersectionDeclaration({ withParentheses: true, nodes: buildMemberNodes(node.members, this.transform) }) ?? undefined
       },
       array(node) {
-        const itemNodes = (node.items ?? []).map((item) => this.print(item)).filter(Boolean)
+        const itemNodes = (node.items ?? []).map((item) => this.transform(item)).filter(Boolean)
 
         return factory.createArrayDeclaration({ nodes: itemNodes, arrayType: this.options.arrayType }) ?? undefined
       },
       tuple(node) {
-        return buildTupleNode(node, this.print)
+        return buildTupleNode(node, this.transform)
       },
       object(node) {
-        const { print, options } = this
+        const { transform, options } = this
+
         const addsQuestionToken = OPTIONAL_ADDS_QUESTION_TOKEN.has(options.optionalType)
 
         const propertyNodes: Array<ts.TypeElement> = node.properties.map((prop) => {
-          const baseType = print(prop.schema) ?? factory.keywordTypeNodes.unknown
+          const baseType = transform(prop.schema) ?? factory.keywordTypeNodes.unknown
           const type = buildPropertyType(prop.schema, baseType, options.optionalType)
 
           const propertyNode = factory.createPropertySignature({
@@ -325,7 +327,7 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
           return factory.appendJSDocToNode({ node: propertyNode, comments: buildPropertyJSDocComments(prop.schema) })
         })
 
-        const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, print)]
+        const allElements = [...propertyNodes, ...buildIndexSignatures(node, propertyNodes.length, transform)]
 
         if (!allElements.length) {
           return factory.keywordTypeNodes.object
@@ -335,10 +337,10 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
       },
     },
     print(node) {
-      let type = this.print(node)
+      let type = this.transform(node)
 
       if (!type) {
-        return undefined
+        return null
       }
 
       // Apply top-level nullable / optional union modifiers.
@@ -353,12 +355,12 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
       // Without typeName, return the type node as-is (no declaration wrapping).
       const { typeName, syntaxType = 'type', description, keysToOmit } = this.options
       if (!typeName) {
-        return type
+        return safePrint(type)
       }
 
       const useTypeGeneration = syntaxType === 'type' || type.kind === factory.syntaxKind.union || !!keysToOmit?.length
 
-      return factory.createTypeDeclaration({
+      const typeNode = factory.createTypeDeclaration({
         name: typeName,
         isExportable: true,
         type: keysToOmit?.length
@@ -380,6 +382,8 @@ export const printerTs = definePrinter<TsPrinter>((options) => {
           node?.example ? `@example ${node.example}` : undefined,
         ],
       })
+
+      return safePrint(typeNode)
     },
   }
 })

package/src/resolvers/resolverTs.ts

@@ -27,6 +27,7 @@ function resolveName(name: string, type?: 'file' | 'function' | 'type' | 'const'
 export const resolverTs = defineResolver<PluginTs>(() => {
   return {
     name: 'default',
+    pluginName: 'plugin-ts',
     default(name, type) {
       return resolveName(name, type)
     },
@@ -86,11 +87,13 @@ export const resolverTs = defineResolver<PluginTs>(() => {
         "resolvePathParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.",
       )
     },
-    resolveQueryParamsName(node) {
-      return this.resolveName(`${node.operationId} QueryParams`)
+    resolveQueryParamsName(_node) {
+      throw new Error("resolveQueryParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.")
     },
-    resolveQueryParamsTypedName(node) {
-      return this.resolveTypedName(`${node.operationId} QueryParams`)
+    resolveQueryParamsTypedName(_node) {
+      throw new Error(
+        "resolveQueryParamsTypedName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamTypedName per individual parameter instead.",
+      )
     },
     resolveHeaderParamsName(_node) {
       throw new Error("resolveHeaderParamsName is only available with compatibilityPreset: 'kubbV4'. Use resolveParamName per individual parameter instead.")

package/src/resolvers/resolverTsLegacy.ts

@@ -28,7 +28,7 @@ import { resolverTs } from './resolverTs.ts'
 export const resolverTsLegacy = defineResolver<PluginTs>(() => {
   return {
     ...resolverTs,
-    name: 'legacy',
+    pluginName: 'plugin-ts',
     resolveResponseStatusName(node, statusCode) {
       if (statusCode === 'default') {
         return this.resolveName(`${node.operationId} Error`)