@kubb/plugin-ts 5.0.0-alpha.29 → 5.0.0-alpha.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-ts",
-  "version": "5.0.0-alpha.29",
+  "version": "5.0.0-alpha.30",
   "description": "TypeScript code generation plugin for Kubb, transforming OpenAPI schemas into TypeScript interfaces, types, and utility functions.",
   "keywords": [
     "typescript",
@@ -53,8 +53,8 @@
     "@kubb/react-fabric": "0.15.1",
     "remeda": "^2.33.7",
     "typescript": "5.9.3",
-    "@kubb/ast": "5.0.0-alpha.29",
-    "@kubb/core": "5.0.0-alpha.29"
+    "@kubb/ast": "5.0.0-alpha.30",
+    "@kubb/core": "5.0.0-alpha.30"
   },
   "peerDependencies": {
     "@kubb/react-fabric": "0.15.1"

package/src/generators/typeGenerator.tsx

@@ -1,7 +1,6 @@
-import path from 'node:path'
-import { caseParams, narrowSchema, schemaTypes, transform } from '@kubb/ast'
+import { caseParams, narrowSchema, schemaTypes } from '@kubb/ast'
 import type { SchemaNode } from '@kubb/ast/types'
-import { defineGenerator, getMode } from '@kubb/core'
+import { defineGenerator } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
@@ -11,18 +10,14 @@ import { buildData, buildResponses, buildResponseUnion } from '../utils.ts'
 
 export const typeGenerator = defineGenerator<PluginTs>({
   name: 'typescript',
-  type: 'react',
-  Schema({ node, adapter, options, config, resolver, plugin }) {
+  schema(node, options) {
     const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group, printer } = options
+    const { adapter, config, resolver, root } = this
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    if (!transformedNode.name) {
+    if (!node.name) {
       return
     }
-
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
     // Build a set of schema names that are enums so the ref handler and getImports
     // callback can use the suffixed type name (e.g. `StatusKey`) for those refs.
     const enumSchemaNames = new Set((adapter.rootNode?.schemas ?? []).filter((s) => narrowSchema(s, schemaTypes.enum) && s.name).map((s) => s.name!))
@@ -34,19 +29,16 @@ export const typeGenerator = defineGenerator<PluginTs>({
       return resolver.resolveTypeName(schemaName)
     }
 
-    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+    const imports = adapter.getImports(node, (schemaName) => ({
       name: resolveImportName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum)
+    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
 
     const meta = {
-      name:
-        ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema
-          ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix)
-          : resolver.resolveTypeName(transformedNode.name),
-      file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
+      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
     const schemaPrinter = printerTs({
@@ -56,7 +48,7 @@ export const typeGenerator = defineGenerator<PluginTs>({
       enumTypeSuffix,
       name: meta.name,
       syntaxType,
-      description: transformedNode.description,
+      description: node.description,
       resolver,
       enumSchemaNames,
       nodes: printer?.nodes,
@@ -72,11 +64,11 @@ export const typeGenerator = defineGenerator<PluginTs>({
       >
         {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 />
+            <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
           ))}
         <Type
           name={meta.name}
-          node={transformedNode}
+          node={node}
           enumType={enumType}
           enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
@@ -86,21 +78,16 @@ export const typeGenerator = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver, plugin }) {
+  operation(node, options) {
     const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output, printer } = options
+    const { adapter, config, resolver, root } = this
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
 
-    const params = caseParams(transformedNode.parameters, paramsCasing)
+    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 },
-      ),
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
     } as const
 
     // Build a set of schema names that are enums so the ref handler and getImports
@@ -158,47 +145,47 @@ export const typeGenerator = defineGenerator<PluginTs>({
     const paramTypes = params.map((param) =>
       renderSchemaType({
         schema: param.schema,
-        name: resolver.resolveParamName(transformedNode, param),
+        name: resolver.resolveParamName(node, param),
       }),
     )
 
-    const requestType = transformedNode.requestBody?.schema
+    const requestType = node.requestBody?.schema
       ? renderSchemaType({
           schema: {
-            ...transformedNode.requestBody.schema,
-            description: transformedNode.requestBody.description ?? transformedNode.requestBody.schema.description,
+            ...node.requestBody.schema,
+            description: node.requestBody.description ?? node.requestBody.schema.description,
           },
-          name: resolver.resolveDataName(transformedNode),
-          keysToOmit: transformedNode.requestBody.keysToOmit,
+          name: resolver.resolveDataName(node),
+          keysToOmit: node.requestBody.keysToOmit,
         })
       : null
 
-    const responseTypes = transformedNode.responses.map((res) =>
+    const responseTypes = node.responses.map((res) =>
       renderSchemaType({
         schema: res.schema,
-        name: resolver.resolveResponseStatusName(transformedNode, res.statusCode),
+        name: resolver.resolveResponseStatusName(node, res.statusCode),
         keysToOmit: res.keysToOmit,
       }),
     )
 
     const dataType = renderSchemaType({
-      schema: buildData({ ...transformedNode, parameters: params }, { resolver }),
-      name: resolver.resolveRequestConfigName(transformedNode),
+      schema: buildData({ ...node, parameters: params }, { resolver }),
+      name: resolver.resolveRequestConfigName(node),
     })
 
     const responsesType = renderSchemaType({
-      schema: buildResponses(transformedNode, { resolver }),
-      name: resolver.resolveResponsesName(transformedNode),
+      schema: buildResponses(node, { resolver }),
+      name: resolver.resolveResponsesName(node),
     })
 
     const responseType = renderSchemaType({
-      schema: transformedNode.responses.some((res) => res.schema)
+      schema: node.responses.some((res) => res.schema)
         ? {
-            ...buildResponseUnion(transformedNode, { resolver })!,
+            ...buildResponseUnion(node, { resolver })!,
             description: 'Union of all possible responses',
           }
         : null,
-      name: resolver.resolveResponseName(transformedNode),
+      name: resolver.resolveResponseName(node),
     })
 
     return (

package/src/generators/typeGeneratorLegacy.tsx

@@ -1,8 +1,7 @@
-import path from 'node:path'
 import { pascalCase } from '@internals/utils'
 import { caseParams, createProperty, createSchema, narrowSchema, schemaTypes, transform } from '@kubb/ast'
 import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
-import { defineGenerator, getMode } from '@kubb/core'
+import { defineGenerator } from '@kubb/core'
 import { File } from '@kubb/react-fabric'
 import { Type } from '../components/Type.tsx'
 import { ENUM_TYPES_WITH_KEY_SUFFIX } from '../constants.ts'
@@ -158,32 +157,26 @@ function nameUnnamedEnums(node: SchemaNode, parentName: string): SchemaNode {
 
 export const typeGeneratorLegacy = defineGenerator<PluginTs>({
   name: 'typescript-legacy',
-  type: 'react',
-  Schema({ node, adapter, options, config, resolver, plugin }) {
+  schema(node, options) {
     const { enumType, enumTypeSuffix, enumKeyCasing, syntaxType, optionalType, arrayType, output, group } = options
+    const { adapter, config, resolver, root } = this
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    if (!transformedNode.name) {
+    if (!node.name) {
       return
     }
 
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
 
-    const imports = adapter.getImports(transformedNode, (schemaName) => ({
+    const imports = adapter.getImports(node, (schemaName) => ({
       name: resolver.resolveTypeName(schemaName),
       path: resolver.resolveFile({ name: schemaName, extname: '.ts' }, { root, output, group }).path,
     }))
 
-    const isEnumSchema = !!narrowSchema(transformedNode, schemaTypes.enum)
+    const isEnumSchema = !!narrowSchema(node, schemaTypes.enum)
 
     const meta = {
-      name:
-        ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema
-          ? resolver.resolveEnumKeyName(transformedNode, enumTypeSuffix)
-          : resolver.resolveTypeName(transformedNode.name),
-      file: resolver.resolveFile({ name: transformedNode.name, extname: '.ts' }, { root, output, group }),
+      name: ENUM_TYPES_WITH_KEY_SUFFIX.has(enumType) && isEnumSchema ? resolver.resolveEnumKeyName(node, enumTypeSuffix) : resolver.resolveTypeName(node.name),
+      file: resolver.resolveFile({ name: node.name, extname: '.ts' }, { root, output, group }),
     } as const
 
     const schemaPrinter = printerTs({
@@ -193,7 +186,7 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       enumTypeSuffix,
       name: meta.name,
       syntaxType,
-      description: transformedNode.description,
+      description: node.description,
       resolver,
     })
 
@@ -207,11 +200,11 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       >
         {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 />
+            <File.Import key={[node.name, imp.path, imp.isTypeOnly].join('-')} root={meta.file.path} path={imp.path} name={imp.name} isTypeOnly />
           ))}
         <Type
           name={meta.name}
-          node={transformedNode}
+          node={node}
           enumType={enumType}
           enumTypeSuffix={enumTypeSuffix}
           enumKeyCasing={enumKeyCasing}
@@ -221,20 +214,15 @@ export const typeGeneratorLegacy = defineGenerator<PluginTs>({
       </File>
     )
   },
-  Operation({ node, adapter, options, config, resolver, plugin }) {
+  operation(node, options) {
     const { enumType, enumTypeSuffix, enumKeyCasing, optionalType, arrayType, syntaxType, paramsCasing, group, output } = options
+    const { adapter, config, resolver, root } = this
 
-    const transformedNode = plugin.transformer ? transform(node, plugin.transformer) : node
-
-    const root = path.resolve(config.root, config.output.path)
-    const mode = getMode(path.resolve(root, output.path))
+    const mode = this.getMode(output)
     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 },
-      ),
+      file: resolver.resolveFile({ name: node.operationId, extname: '.ts', tag: node.tags[0] ?? 'default', path: node.path }, { root, output, group }),
     } as const
 
     function renderSchemaType({

package/src/plugin.ts

@@ -1,8 +1,6 @@
-import path from 'node:path'
 import { camelCase } from '@internals/utils'
-import { walk } from '@kubb/ast'
-import type { OperationNode } from '@kubb/ast/types'
-import { createPlugin, type Group, getBarrelFiles, getPreset, runGeneratorOperation, runGeneratorOperations, runGeneratorSchema } from '@kubb/core'
+import { createPlugin, type Group, getPreset, mergeGenerators } from '@kubb/core'
+import { version } from '../package.json'
 import { presets } from './presets.ts'
 import type { PluginTs } from './types.ts'
 
@@ -56,11 +54,15 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     generators: userGenerators,
   })
 
+  const generators = preset.generators ?? []
+  const mergedGenerator = mergeGenerators(generators)
+
   let resolveNameWarning = false
   let resolvePathWarning = false
 
   return {
     name: pluginTsName,
+    version,
     get resolver() {
       return preset.resolver
     },
@@ -70,6 +72,9 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     get options() {
       return {
         output,
+        exclude,
+        include,
+        override,
         optionalType,
         group: group
           ? ({
@@ -93,65 +98,34 @@ export const pluginTs = createPlugin<PluginTs>((options) => {
     },
     resolvePath(baseName, pathMode, options) {
       if (!resolvePathWarning) {
-        this.events.emit('warn', 'Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
+        this.warn('Do not use resolvePath for pluginTs, use resolverTs.resolvePath instead')
         resolvePathWarning = true
       }
 
       return this.plugin.resolver.resolvePath(
         { baseName, pathMode, tag: options?.group?.tag, path: options?.group?.path },
-        { root: path.resolve(this.config.root, this.config.output.path), output, group: this.plugin.options.group },
+        { root: this.root, output, group: this.plugin.options.group },
       )
     },
     resolveName(name, type) {
       if (!resolveNameWarning) {
-        this.events.emit('warn', 'Do not use resolveName for pluginTs, use resolverTs.default instead')
+        this.warn('Do not use resolveName for pluginTs, use resolverTs.default instead')
         resolveNameWarning = true
       }
 
       return this.plugin.resolver.default(name, type)
     },
-    async install() {
-      const { config, fabric, plugin, adapter, rootNode, driver, openInStudio, resolver } = this
-
-      const root = path.resolve(config.root, config.output.path)
-
-      if (!adapter) {
-        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) {
-          await runGeneratorSchema(schemaNode, generatorContext)
-        },
-        async operation(operationNode) {
-          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,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
+    async schema(node, options) {
+      return mergedGenerator.schema?.call(this, node, options)
+    },
+    async operation(node, options) {
+      return mergedGenerator.operation?.call(this, node, options)
+    },
+    async operations(nodes, options) {
+      return mergedGenerator.operations?.call(this, nodes, options)
+    },
+    async buildStart() {
+      await this.openInStudio({ ast: true })
     },
   }
 })

package/src/types.ts

@@ -276,7 +276,7 @@ export type Options = {
    */
   transformer?: Visitor
   /**
-   * Override individual printer node handlers to customise rendering of specific schema types.
+   * Override individual printer node handlers to customize rendering of specific schema types.
    *
    * Each key is a `SchemaType` (e.g. `'date'`, `'string'`). The function replaces the
    * built-in handler for that type. Use `this.transform` to recurse into nested schema nodes.
@@ -302,6 +302,9 @@ export type Options = {
 
 type ResolvedOptions = {
   output: Output
+  exclude: Array<Exclude>
+  include: Array<Include> | undefined
+  override: Array<Override<ResolvedOptions>>
   group: Group | undefined
   enumType: NonNullable<Options['enumType']>
   enumTypeSuffix: NonNullable<Options['enumTypeSuffix']>
@@ -314,3 +317,11 @@ type ResolvedOptions = {
 }
 
 export type PluginTs = PluginFactoryOptions<'plugin-ts', Options, ResolvedOptions, never, ResolvePathOptions, ResolverTs>
+
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-ts': PluginTs
+    }
+  }
+}