@kubb/plugin-ts 5.0.0-alpha.24 → 5.0.0-alpha.26

package/src/generators/typeGeneratorLegacy.tsx

@@ -32,11 +32,10 @@ function buildGroupedParamsSchema({ params, parentName }: BuildGroupedParamsSche
 }
 
 type BuildOperationSchemaOptions = {
-  node: OperationNode
   resolver: ResolverTs
 }
 
-function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchemaOptions): SchemaNode | null {
+function buildLegacyResponsesSchemaNode(node: OperationNode, { resolver }: BuildOperationSchemaOptions): SchemaNode | null {
   const isGet = node.method.toLowerCase() === 'get'
   const successResponses = node.responses.filter((res) => {
     const code = Number(res.statusCode)
@@ -52,7 +51,7 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
             type: 'union',
             members: successResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
-      : createSchema({ type: 'any' })
+      : createSchema({ type: 'any', primitive: undefined })
 
   const errorsSchema =
     errorResponses.length > 0
@@ -62,7 +61,7 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
             type: 'union',
             members: errorResponses.map((res) => createSchema({ type: 'ref', name: resolver.resolveResponseStatusName(node, res.statusCode) })),
           })
-      : createSchema({ type: 'any' })
+      : createSchema({ type: 'any', primitive: undefined })
 
   const properties = [createProperty({ name: 'Response', required: true, schema: responseSchema })]
 
@@ -114,14 +113,14 @@ function buildLegacyResponsesSchemaNode({ node, resolver }: BuildOperationSchema
   return createSchema({ type: 'object', properties })
 }
 
-function buildLegacyResponseUnionSchemaNode({ node, resolver }: BuildOperationSchemaOptions): SchemaNode {
+function buildLegacyResponseUnionSchemaNode(node: OperationNode, { 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' })
+    return createSchema({ type: 'any', primitive: undefined })
   }
 
   if (successResponses.length === 1) {
@@ -159,33 +158,89 @@ function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
 export const typeGeneratorLegacy = defineGenerator<PluginTs>({
   name: 'typescript-legacy',
   type: 'react',
+  Schema({ node, adapter, options, config, resolver }) {
+    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, transformers = [] } = options
+
+    const transformedNode = transform(node, composeTransformers(...transformers))
+
+    if (!transformedNode.name) {
+      return
+    }
+
+    const root = path.resolve(config.root, config.output.path)
+    const mode = getMode(path.resolve(root, output.path))
+
+    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(transformedNode, schemaTypes.enum)
+
+    const meta = {
+      name:
+        ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema
+          ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix)
+          : resolver.resolveName(transformedNode.name),
+      file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
+    } as const
+
+    return (
+      <File
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
+        banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
+        footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
+      >
+        {mode === 'split' &&
+          imports.map((imp) => (
+            <File.Import key={[transformedNode.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
+          ))}
+        <Type
+          name={meta.name}
+          node={transformedNode}
+          enumType={enumType}
+          enumTypeSuffix={enumTypeSuffix}
+          enumKeyCasing={enumKeyCasing}
+          optionalType={optionalType}
+          arrayType={arrayType}
+          syntaxType={syntaxType}
+          resolver={resolver}
+        />
+      </File>
+    )
+  },
   Operation({ node, adapter, options, config, resolver }) {
     const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, transformers = [] } = options
 
+    const transformedNode = transform(node, composeTransformers(...transformers))
+
     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)
 
+    const meta = {
+      file: resolver.resolveFile(
+        { name: transformedNode.operationId, extname: '.ts', tag: transformedNode.tags[0] ?? 'default', path: transformedNode.path },
+        { root, output, group },
+      ),
+    } as const
+
     function renderSchemaType({
-      node: schemaNode,
+      schema,
       name,
       description,
       keysToOmit,
     }: {
-      node: SchemaNode | null
+      schema: SchemaNode | null
       name: string
       description?: string
       keysToOmit?: Array<string>
     }) {
-      if (!schemaNode) {
-        return null
-      }
-
-      const transformedNode = transform(schemaNode, composeTransformers(...transformers))
+      if (!schema) return null
 
-      const imports = adapter.getImports(transformedNode, (schemaName) => ({
+      const imports = adapter.getImports(schema, (schemaName) => ({
         name: resolver.default(schemaName, 'type'),
         path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
       }))
@@ -193,10 +248,12 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       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 />)}
+            imports.map((imp) => (
+              <File.Import key={[name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
+            ))}
           <Type
             name={name}
-            node={transformedNode}
+            node={schema}
             description={description}
             enumType={enumType}
             enumTypeSuffix={enumTypeSuffix}
@@ -220,7 +277,7 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       const baseResponseName = resolverTsLegacy.resolveResponseStatusName(node, res.statusCode)
 
       return renderSchemaType({
-        node: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
+        schema: res.schema ? nameUnnamedEnums(res.schema, baseResponseName) : res.schema,
         name: responseName,
         description: res.description,
         keysToOmit: res.keysToOmit,
@@ -229,7 +286,7 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
 
     const requestType = node.requestBody?.schema
       ? renderSchemaType({
-          node: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
+          schema: nameUnnamedEnums(node.requestBody.schema, resolverTsLegacy.resolveDataName(node)),
           name: resolver.resolveDataName(node),
           description: node.requestBody.description ?? node.requestBody.schema.description,
           keysToOmit: node.requestBody.keysToOmit,
@@ -239,39 +296,39 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
     const legacyParamTypes = [
       pathParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0]!) }),
+            schema: buildGroupedParamsSchema({ params: pathParams, parentName: resolverTsLegacy.resolvePathParamsName(node, pathParams[0]!) }),
             name: resolver.resolvePathParamsName(node, pathParams[0]!),
           })
         : null,
       queryParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0]!) }),
+            schema: buildGroupedParamsSchema({ params: queryParams, parentName: resolverTsLegacy.resolveQueryParamsName(node, queryParams[0]!) }),
             name: resolver.resolveQueryParamsName(node, queryParams[0]!),
           })
         : null,
       headerParams.length > 0
         ? renderSchemaType({
-            node: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0]!) }),
+            schema: buildGroupedParamsSchema({ params: headerParams, parentName: resolverTsLegacy.resolveHeaderParamsName(node, headerParams[0]!) }),
             name: resolver.resolveHeaderParamsName(node, headerParams[0]!),
           })
         : null,
     ]
 
     const legacyResponsesType = renderSchemaType({
-      node: buildLegacyResponsesSchemaNode({ node, resolver }),
+      schema: buildLegacyResponsesSchemaNode(node, { resolver }),
       name: resolver.resolveResponsesName(node),
     })
 
     const legacyResponseType = renderSchemaType({
-      node: buildLegacyResponseUnionSchemaNode({ node, resolver }),
+      schema: buildLegacyResponseUnionSchemaNode(node, { resolver }),
       name: resolver.resolveResponseName(node),
     })
 
     return (
       <File
-        baseName={file.baseName}
-        path={file.path}
-        meta={file.meta}
+        baseName={meta.file.baseName}
+        path={meta.file.path}
+        meta={meta.file.meta}
         banner={resolver.resolveBanner(adapter.rootNode, { output, config })}
         footer={resolver.resolveFooter(adapter.rootNode, { output, config })}
       >
@@ -283,56 +340,4 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Schema({ node, adapter, options, config, resolver }) {
-    const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, 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 name = ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveName(node.name)
-
-    const type = {
-      name,
-      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}
-          node={transformedNode}
-          enumType={enumType}
-          enumTypeSuffix={enumTypeSuffix}
-          enumKeyCasing={enumKeyCasing}
-          optionalType={optionalType}
-          arrayType={arrayType}
-          syntaxType={syntaxType}
-          resolver={resolver}
-        />
-      </File>
-    )
-  },
 })

package/src/index.ts

@@ -1,14 +1,9 @@
 export { Enum } from './components/Enum.tsx'
 export { Type } from './components/Type.tsx'
-
 export { typeGenerator } from './generators/typeGenerator.tsx'
-
 export { pluginTs, pluginTsName } from './plugin.ts'
-
 export { functionPrinter } from './printers/functionPrinter.ts'
 export { printerTs } from './printers/printerTs.ts'
-
 export { resolverTs } from './resolvers/resolverTs.ts'
 export { resolverTsLegacy } from './resolvers/resolverTsLegacy.ts'
-
 export type { PluginTs, ResolverTs } from './types.ts'

package/src/plugin.ts

@@ -1,7 +1,8 @@
 import path from 'node:path'
 import { camelCase } from '@internals/utils'
 import { walk } from '@kubb/ast'
-import { createPlugin, type Group, getBarrelFiles, getPreset, renderOperation, renderSchema } from '@kubb/core'
+import type { OperationNode } from '@kubb/ast/types'
+import { createPlugin, type Group, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from '@kubb/core'
 import { presets } from './presets.ts'
 import type { PluginTs } from './types.ts'
 
@@ -68,14 +69,14 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
         optionalType,
         group: group
           ? ({
-              ...options.group,
+              ...group,
               name: (ctx) => {
-                if (options.group?.type === 'path') {
+                if (group.type === 'path') {
                   return `${ctx.group.split('/')[1]}`
                 }
                 return `${camelCase(ctx.group)}Controller`
               },
-            } as Group)
+            } satisfies Group)
           : undefined,
         arrayType,
         enumType,
@@ -111,63 +112,32 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
       const root = path.resolve(config.root, config.output.path)
 
       if (!adapter) {
-        throw new Error('Plugin cannot work without adapter being set')
+        throw new Error(`[${pluginTsName}] No adapter found. Add an OAS adapter (e.g. pluginOas()) before this plugin in your Kubb config.`)
       }
 
       await openInStudio({ ast: true })
 
+      const collectedOperations: Array<OperationNode> = []
+      const generatorContext = { generators: preset.generators, plugin, resolver, exclude, include, override, fabric, adapter, config, driver }
+
       await walk(rootNode, {
         depth: 'shallow',
         async schema(schemaNode) {
-          const writeTasks = preset.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,
-                resolver,
-                adapter,
-                config,
-                fabric,
-                Component: generator.Schema,
-                plugin,
-                driver,
-              })
-            }
-          })
-
-          await Promise.all(writeTasks)
+          await runGeneratorSchema(schemaNode, generatorContext)
         },
         async operation(operationNode) {
-          const writeTasks = preset.generators.map(async (generator) => {
-            if (generator.type === 'react' && generator.version === '2') {
-              const options = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
-
-              if (options === null) {
-                return
-              }
-
-              await renderOperation(operationNode, {
-                options,
-                resolver,
-                adapter,
-                config,
-                fabric,
-                Component: generator.Operation,
-                plugin,
-                driver,
-              })
-            }
-          })
-
-          await Promise.all(writeTasks)
+          const baseOptions = resolver.resolveOptions(operationNode, { options: plugin.options, exclude, include, override })
+
+          if (baseOptions !== null) {
+            collectedOperations.push(operationNode)
+          }
+
+          await runGeneratorOperation(operationNode, generatorContext)
         },
       })
 
+      await runGeneratorOperations(collectedOperations, generatorContext)
+
       const barrelFiles = await getBarrelFiles(this.fabric.files, {
         type: output.barrelType ?? 'named',
         root,

package/src/printers/functionPrinter.ts

@@ -1,6 +1,7 @@
 import type { PrinterFactoryOptions } from '@kubb/ast'
 import { createPrinterFactory } from '@kubb/ast'
 import type { FunctionNode, FunctionNodeType, FunctionParameterNode, FunctionParametersNode, ParameterGroupNode, TypeNode } from '@kubb/ast/types'
+import { PARAM_RANK } from '../constants.ts'
 
 /**
  * Maps each function-printer handler key to its concrete node type.
@@ -53,13 +54,13 @@ type DefaultPrinter = PrinterFactoryOptions<'functionParameters', FunctionPrinte
 
 function rank(param: FunctionParameterNode | ParameterGroupNode): number {
   if (param.kind === 'ParameterGroup') {
-    if (param.default) return 2
+    if (param.default) return PARAM_RANK.withDefault
     const isOptional = param.optional ?? param.properties.every((p) => p.optional || p.default !== undefined)
-    return isOptional ? 1 : 0
+    return isOptional ? PARAM_RANK.optional : PARAM_RANK.required
   }
-  if (param.rest) return 3
-  if (param.default) return 2
-  return param.optional ? 1 : 0
+  if (param.rest) return PARAM_RANK.rest
+  if (param.default) return PARAM_RANK.withDefault
+  return param.optional ? PARAM_RANK.optional : PARAM_RANK.required
 }
 
 function sortParams(params: ReadonlyArray<FunctionParameterNode | ParameterGroupNode>): Array<FunctionParameterNode | ParameterGroupNode> {