@kubb/core 2.0.0-beta.1 → 2.0.0-beta.10

package/src/FileManager.ts

@@ -1,6 +1,6 @@
 /* eslint-disable @typescript-eslint/no-namespace */
 import crypto from 'node:crypto'
-import { extname } from 'node:path'
+import { extname, resolve } from 'node:path'
 
 import { print } from '@kubb/parser'
 import * as factory from '@kubb/parser/factory'
@@ -8,9 +8,9 @@ import * as factory from '@kubb/parser/factory'
 import isEqual from 'lodash.isequal'
 import { orderBy } from 'natural-orderby'
 
-import { read } from './utils/read.ts'
+import transformers from './transformers/index.ts'
+import { getRelativePath, read } from './utils/read.ts'
 import { timeout } from './utils/timeout.ts'
-import { transformers } from './utils/transformers/index.ts'
 import { write } from './utils/write.ts'
 import { BarrelManager } from './BarrelManager.ts'
 
@@ -28,7 +28,14 @@ export namespace KubbFile {
      * @example ["useState"]
      * @example "React"
      */
-    name: string | Array<string>
+    name:
+      | string
+      | Array<
+        string | {
+          propertyName: string
+          name?: string
+        }
+      >
     /**
      * Path for the import
      * @xample '@kubb/core'
@@ -38,6 +45,14 @@ export namespace KubbFile {
      * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`.
      */
     isTypeOnly?: boolean
+    /**
+     * Add `* as` prefix to the import, this will result in: `import * as path from './path'`.
+     */
+    isNameSpace?: boolean
+    /**
+     * When root is set it will get the path with relative getRelativePath(root, path).
+     */
+    root?: string
   }
 
   export type Export = {
@@ -104,8 +119,8 @@ export namespace KubbFile {
      */
     id?: string
     /**
-     * Name to be used to dynamicly create the baseName(based on input.path)
-     * Based on UNIX basename
+     * Name to be used to create the path
+     * Based on UNIX basename, `${name}.extName`
      * @link https://nodejs.org/api/path.html#pathbasenamepath-suffix
      */
     baseName: TBaseName
@@ -130,10 +145,6 @@ export namespace KubbFile {
      * This will override `process.env[key]` inside the `source`, see `getFileSource`.
      */
     env?: NodeJS.ProcessEnv
-    /**
-     * @deprecated
-     */
-    validate?: boolean
   }
 
   export type ResolvedFile<
@@ -144,6 +155,12 @@ export namespace KubbFile {
      * @default crypto.randomUUID()
      */
     id: UUID
+    /**
+     * Contains the first part of the baseName, generated based on baseName
+     * @link  https://nodejs.org/api/path.html#pathformatpathobject
+     */
+
+    name: string
   }
 }
 
@@ -156,8 +173,19 @@ type AddResult<T extends Array<KubbFile.File>> = Promise<
 >
 
 type AddIndexesProps = {
-  root: KubbFile.Path
-  extName?: KubbFile.Extname
+  /**
+   * Root based on root and output.path specified in the config
+   */
+  root: string
+  /**
+   * Output for plugin
+   */
+  output: {
+    path: string
+    exportAs?: string
+    extName?: KubbFile.Extname
+    exportType?: 'barrel' | false
+  }
   options?: BarrelManagerOptions
   meta?: KubbFile.File['meta']
 }
@@ -205,10 +233,6 @@ export class FileManager {
   }
 
   #validate(file: KubbFile.File): void {
-    if (!file.validate) {
-      return
-    }
-
     if (!file.path.toLowerCase().endsWith(file.baseName.toLowerCase())) {
       throw new Error(`${file.path} should end with the baseName ${file.baseName}`)
     }
@@ -218,7 +242,7 @@ export class FileManager {
     ...files: T
   ): AddResult<T> {
     const promises = files.map((file) => {
-      this.#validate(file)
+      // this.#validate(file)
 
       if (file.override) {
         return this.#add(file)
@@ -238,7 +262,7 @@ export class FileManager {
 
   async #add(file: KubbFile.File): Promise<KubbFile.ResolvedFile> {
     const controller = new AbortController()
-    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), ...file }
+    const resolvedFile: KubbFile.ResolvedFile = { id: crypto.randomUUID(), name: transformers.trimExtName(file.baseName), ...file }
 
     this.#cache.set(resolvedFile.path, [{ cancel: () => controller.abort(), ...resolvedFile }])
 
@@ -272,15 +296,45 @@ export class FileManager {
     return this.#add(file)
   }
 
-  async addIndexes({ root, extName = '.ts', meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
-    const barrelManager = new BarrelManager(options)
+  async addIndexes({ root, output, meta, options = {} }: AddIndexesProps): Promise<Array<KubbFile.File> | undefined> {
+    const { exportType = 'barrel' } = output
+
+    if (!exportType) {
+      return undefined
+    }
 
-    const files = barrelManager.getIndexes(root, extName)
+    const exportPath = output.path.startsWith('./') ? output.path : `./${output.path}`
+    const barrelManager = new BarrelManager({ extName: output.extName, ...options })
+    const files = barrelManager.getIndexes(resolve(root, output.path))
 
     if (!files) {
       return undefined
     }
 
+    const rootFile: KubbFile.File = {
+      path: resolve(root, 'index.ts'),
+      baseName: 'index.ts',
+      source: '',
+      exports: [
+        output.exportAs
+          ? {
+            name: output.exportAs,
+            asAlias: true,
+            path: exportPath,
+            isTypeOnly: options.isTypeOnly,
+          }
+          : {
+            path: exportPath,
+            isTypeOnly: options.isTypeOnly,
+          },
+      ],
+    }
+
+    await this.#addOrAppend({
+      ...rootFile,
+      meta: meta ? meta : rootFile.meta,
+    })
+
     return await Promise.all(
       files.map((file) => {
         return this.#addOrAppend({
@@ -342,9 +396,24 @@ export class FileManager {
     const exports = file.exports ? combineExports(file.exports) : []
     const imports = file.imports ? combineImports(file.imports, exports, file.source) : []
 
-    const importNodes = imports.map((item) => factory.createImportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly }))
+    const importNodes = imports.filter(item => {
+      // isImportNotNeeded
+      // trim extName
+      return item.path !== transformers.trimExtName(file.path)
+    }).map((item) => {
+      return factory.createImportDeclaration({
+        name: item.name,
+        path: item.root ? getRelativePath(item.root, item.path) : item.path,
+        isTypeOnly: item.isTypeOnly,
+      })
+    })
     const exportNodes = exports.map((item) =>
-      factory.createExportDeclaration({ name: item.name, path: item.path, isTypeOnly: item.isTypeOnly, asAlias: item.asAlias })
+      factory.createExportDeclaration({
+        name: item.name,
+        path: item.path,
+        isTypeOnly: item.isTypeOnly,
+        asAlias: item.asAlias,
+      })
     )
 
     return [print([...importNodes, ...exportNodes]), getEnvSource(file.source, file.env)].join('\n')
@@ -452,7 +521,7 @@ export function combineImports(imports: Array<KubbFile.Import>, exports: Array<K
     }
 
     if (Array.isArray(name)) {
-      name = name.filter((item) => hasImportInSource(item))
+      name = name.filter((item) => typeof item === 'string' ? hasImportInSource(item) : hasImportInSource(item.propertyName))
     }
 
     const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly)

package/src/PluginManager.ts

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-argument */
 
+import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
 import { LogLevel } from './utils/logger.ts'
 import { Queue } from './utils/Queue.ts'
-import { transformReservedWord } from './utils/transformers/transformReservedWord.ts'
 import { setUniqueName } from './utils/uniqueName.ts'
 import { ValidationPluginError } from './errors.ts'
 import { FileManager } from './FileManager.ts'
@@ -129,11 +129,11 @@ export class PluginManager {
         parameters: [params.baseName, params.directory, params.options as object],
       })
 
-      if (paths && paths?.length > 1) {
-        throw new Error(
+      if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+        this.logger.warn(
           `Cannot return a path where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nPaths: ${
             JSON.stringify(paths, undefined, 2)
-          }`,
+          }\n\nFalling back on the first item.\n`,
         )
       }
 
@@ -153,11 +153,11 @@ export class PluginManager {
         parameters: [params.name, params.type],
       })
 
-      if (names && names?.length > 1) {
-        throw new Error(
+      if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
+        this.logger.warn(
           `Cannot return a name where the 'pluginKey' ${params.pluginKey ? JSON.stringify(params.pluginKey) : '"'} is not unique enough\n\nNames: ${
             JSON.stringify(names, undefined, 2)
-          }`,
+          }\n\nFalling back on the first item.\n`,
         )
       }
 
@@ -379,7 +379,7 @@ export class PluginManager {
     const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
 
     if (hookName) {
-      if (this.logger.logLevel === 'info') {
+      if (this.logger.logLevel === LogLevel.info) {
         const containsHookName = plugins.some((item) => item[hookName])
         if (!containsHookName) {
           this.logger.warn(`No hook ${hookName} found`)
@@ -388,28 +388,46 @@ export class PluginManager {
 
       return plugins.filter((item) => item[hookName])
     }
+    // TODO add test case for sorting with pre/post
 
-    return plugins
+    return plugins.map(plugin => {
+      if (plugin.pre) {
+        const isValid = plugin.pre.every(pluginName => plugins.find(pluginToFind => pluginToFind.name === pluginName))
+
+        if (!isValid) {
+          throw new ValidationPluginError(`This plugin has a pre set that is not valid(${JSON.stringify(plugin.pre, undefined, 2)})`)
+        }
+      }
+
+      return plugin
+    }).sort((a, b) => {
+      if (b.pre?.includes(a.name)) {
+        return 1
+      }
+      if (b.post?.includes(a.name)) {
+        return -1
+      }
+      return 0
+    })
   }
 
   getPluginsByKey(hookName: keyof PluginLifecycle, pluginKey: KubbPlugin['key']): KubbPlugin[] {
     const plugins = [...this.plugins]
-    const [searchKind, searchPluginName, searchIdentifier] = pluginKey
+    const [searchPluginName, searchIdentifier] = pluginKey
 
     const pluginByPluginName = plugins
       .filter((plugin) => plugin[hookName])
       .filter((item) => {
-        const [kind, name, identifier] = item.key
+        const [name, identifier] = item.key
 
         const identifierCheck = identifier?.toString() === searchIdentifier?.toString()
-        const kindCheck = kind === searchKind
         const nameCheck = name === searchPluginName
 
         if (searchIdentifier) {
-          return identifierCheck && kindCheck && nameCheck
+          return identifierCheck && nameCheck
         }
 
-        return kindCheck && nameCheck
+        return nameCheck
       })
 
     if (!pluginByPluginName?.length) {
@@ -417,7 +435,7 @@ export class PluginManager {
 
       const corePlugin = plugins.find((plugin) => plugin.name === 'core' && plugin[hookName])
 
-      if (this.logger.logLevel === 'info') {
+      if (this.logger.logLevel === LogLevel.debug) {
         if (corePlugin) {
           this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`)
         } else {
@@ -569,7 +587,7 @@ export class PluginManager {
 
     setUniqueName(plugin.name, usedPluginNames)
 
-    const key = plugin.key || ([plugin.kind, plugin.name, usedPluginNames[plugin.name]].filter(Boolean) as [typeof plugin.kind, typeof plugin.name, string])
+    const key = [plugin.name, usedPluginNames[plugin.name]].filter(Boolean) as [typeof plugin.name, string]
 
     if (plugin.name !== 'core' && usedPluginNames[plugin.name]! >= 2) {
       pluginManager.logger.warn('Using multiple of the same plugin is an experimental feature')
@@ -624,6 +642,6 @@ export class PluginManager {
 
   // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
   static get hooks() {
-    return ['validate', 'buildStart', 'resolvePath', 'resolveName', 'load', 'transform', 'writeFile', 'buildEnd'] as const
+    return ['buildStart', 'resolvePath', 'resolveName', 'load', 'transform', 'writeFile', 'buildEnd'] as const
   }
 }

package/src/build.ts

@@ -116,7 +116,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
         logger.spinner.start(`💾 Writing`)
       }
 
-      if (logger.logLevel === 'debug') {
+      if (logger.logLevel === LogLevel.debug) {
         logger.info(`PluginKey ${pc.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
       }
     }
@@ -157,11 +157,6 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 
   const { fileManager, logger } = pluginManager
 
-  await pluginManager.hookParallel<'validate', true>({
-    hookName: 'validate',
-    parameters: [pluginManager.plugins],
-  })
-
   await pluginManager.hookParallel({
     hookName: 'buildStart',
     parameters: [options.config],
@@ -183,11 +178,6 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
   const { fileManager, logger } = pluginManager
 
   try {
-    await pluginManager.hookParallel<'validate', true>({
-      hookName: 'validate',
-      parameters: [pluginManager.plugins],
-    })
-
     await pluginManager.hookParallel({
       hookName: 'buildStart',
       parameters: [options.config],

package/src/index.ts

@@ -12,7 +12,6 @@ export { PackageManager } from './PackageManager.ts'
 export { createPlugin, pluginName as name, pluginName } from './plugin.ts'
 export { PluginManager } from './PluginManager.ts'
 export { PromiseManager } from './PromiseManager.ts'
-export { SchemaGenerator } from './SchemaGenerator.ts'
 export * from './types.ts'
 
 export interface _Register {}

package/src/plugin.ts

@@ -26,10 +26,10 @@ type Options = {
 }
 
 // not publicly exported
-export type CorePluginOptions = PluginFactoryOptions<'core', 'controller', Options, Options, PluginContext, never>
+export type CorePluginOptions = PluginFactoryOptions<'core', Options, Options, PluginContext, never>
 
 export const pluginName = 'core' satisfies CorePluginOptions['name']
-export const pluginKey: CorePluginOptions['key'] = ['controller', pluginName] satisfies CorePluginOptions['key']
+export const pluginKey: CorePluginOptions['key'] = [pluginName] satisfies CorePluginOptions['key']
 
 export const definePlugin = createPlugin<CorePluginOptions>((options) => {
   const { fileManager, pluginManager, resolvePath, resolveName, logger } = options
@@ -37,8 +37,8 @@ export const definePlugin = createPlugin<CorePluginOptions>((options) => {
   return {
     name: pluginName,
     options,
-    key: ['controller', 'core'],
-    kind: 'controller',
+    key: ['core'],
+
     api() {
       return {
         get config() {

package/src/transformers/casing.ts

@@ -0,0 +1,9 @@
+import { camelCase as changeCaseCamel, camelCaseTransformMerge, pascalCase as changePascalCase, pascalCaseTransformMerge } from 'change-case'
+
+export function camelCase(text: string): string {
+  return changeCaseCamel(text, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: camelCaseTransformMerge })
+}
+
+export function pascalCase(text: string): string {
+  return changePascalCase(text, { delimiter: '', stripRegexp: /[^A-Z0-9$]/gi, transform: pascalCaseTransformMerge })
+}

package/src/transformers/createJSDocBlockText.ts

@@ -0,0 +1,9 @@
+export function createJSDocBlockText({ comments }: { comments: Array<string> }): string {
+  const filteredComments = comments.filter(Boolean)
+
+  if (!filteredComments.length) {
+    return ''
+  }
+
+  return `/**\n * ${filteredComments.join('\n * ')}\n */`
+}

package/src/transformers/index.ts

@@ -0,0 +1,36 @@
+import { camelCase, pascalCase } from './casing.ts'
+import { combineCodes } from './combineCodes.ts'
+import { createJSDocBlockText } from './createJSDocBlockText.ts'
+import { escape, jsStringEscape } from './escape.ts'
+import { createIndent } from './indent.ts'
+import { nameSorter } from './nameSorter.ts'
+import { searchAndReplace } from './searchAndReplace.ts'
+import { transformReservedWord } from './transformReservedWord.ts'
+import { trim, trimExtName } from './trim.ts'
+
+export { camelCase, pascalCase } from './casing.ts'
+export { combineCodes } from './combineCodes.ts'
+export { createJSDocBlockText } from './createJSDocBlockText.ts'
+export { escape, jsStringEscape } from './escape.ts'
+export { createIndent } from './indent.ts'
+export { nameSorter } from './nameSorter.ts'
+export { searchAndReplace } from './searchAndReplace.ts'
+export { transformReservedWord } from './transformReservedWord.ts'
+export { trim, trimExtName } from './trim.ts'
+
+export default {
+  combineCodes,
+  escape,
+  jsStringEscape,
+  createIndent,
+  transformReservedWord,
+  nameSorter,
+  searchAndReplace,
+  trim,
+  trimExtName,
+  JSDoc: {
+    createJSDocBlockText,
+  },
+  camelCase,
+  pascalCase,
+} as const

package/src/transformers/trim.ts

@@ -0,0 +1,7 @@
+export function trim(text: string): string {
+  return text.replaceAll(/\n/g, '').trim()
+}
+
+export function trimExtName(text: string): string {
+  return text.replace(/\.[^/.]+$/, '')
+}

package/src/types.ts

@@ -123,8 +123,6 @@ export type CLIOptions = {
 
 // plugin
 
-export type KubbPluginKind = 'schema' | 'controller'
-
 export type KubbUnionPlugins = PluginUnion
 
 export type KubbObjectPlugin = keyof OptionsPlugins
@@ -134,10 +132,6 @@ export type PluginFactoryOptions<
    * Name to be used for the plugin, this will also be used for they key.
    */
   TName extends string = string,
-  /**
-   * @type "schema" | "controller"
-   */
-  TKind extends KubbPluginKind = KubbPluginKind,
   /**
    * Options of the plugin.
    */
@@ -161,18 +155,17 @@ export type PluginFactoryOptions<
   TAppMeta = unknown,
 > = {
   name: TName
-  kind: TKind
   /**
    * Same behaviour like what has been done with `QueryKey` in `@tanstack/react-query`
    */
-  key: [kind: TKind | undefined, name: TName | string, identifier?: string | number]
+  key: [name: TName | string, identifier?: string | number]
   options: TOptions
   resolvedOptions: TResolvedOptions
   api: TAPI
   resolvePathOptions: TResolvePathOptions
   appMeta: {
     pluginManager: PluginManager
-    plugin: KubbPlugin<PluginFactoryOptions<TName, TKind, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>
+    plugin: KubbPlugin<PluginFactoryOptions<TName, TOptions, TResolvedOptions, TAPI, TResolvePathOptions, TAppMeta>>
   } & TAppMeta
 }
 
@@ -182,18 +175,23 @@ export type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactory
   & {
     /**
      * Unique name used for the plugin
+     * The name of the plugin follows the format scope:foo-bar or foo-bar, adding scope: can avoid naming conflicts with other plugins.
      * @example @kubb/typescript
      */
     name: TOptions['name']
-    /**
-     * Internal key used when a developer uses more than one of the same plugin
-     * @private
-     */
-    key?: TOptions['key']
     /**
      * Options set for a specific plugin(see kubb.config.js), passthrough of options.
      */
     options: TOptions['resolvedOptions']
+    /**
+     * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
+     * Can be used to validate depended plugins.
+     */
+    pre?: Array<string>
+    /**
+     * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
+     */
+    post?: Array<string>
   }
   & (TOptions['api'] extends never ? {
       api?: never
@@ -201,24 +199,10 @@ export type KubbUserPlugin<TOptions extends PluginFactoryOptions = PluginFactory
     : {
       api: (this: TOptions['name'] extends 'core' ? null : Omit<PluginContext<TOptions>, 'addFile'>) => TOptions['api']
     })
-  & (TOptions['kind'] extends never ? {
-      kind?: never
-    }
-    : {
-      /**
-       * Kind/type for the plugin
-       *
-       * Type 'schema' can be used for JSON schema's, TypeScript types, ...
-       *
-       * Type 'controller' can be used to create generate API calls, React-Query hooks, Axios controllers, ...
-       * @default undefined
-       */
-      kind: TOptions['kind']
-    })
 
 export type KubbUserPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbUserPlugin<TOptions> & PluginLifecycle<TOptions>
 
-type UnknownKubbUserPlugin = KubbUserPlugin<PluginFactoryOptions<any, any, any, any, any, any, any>>
+type UnknownKubbUserPlugin = KubbUserPlugin<PluginFactoryOptions<any, any, any, any, any, any>>
 
 export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
   & {
@@ -233,16 +217,18 @@ export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
      */
     key: TOptions['key']
     /**
-     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     * Specifies the preceding plugins for the current plugin. You can pass an array of preceding plugin names, and the current plugin will be executed after these plugins.
+     * Can be used to validate depended plugins.
      */
-    options: TOptions['resolvedOptions']
+    pre?: Array<string>
     /**
-     * Kind/type for the plugin
-     * Type 'schema' can be used for JSON schema's, TypeScript types, ...
-     * Type 'controller' can be used to create generate API calls, React-Query hooks, Axios controllers, ...
-     * @default undefined
+     * Specifies the succeeding plugins for the current plugin. You can pass an array of succeeding plugin names, and the current plugin will be executed before these plugins.
      */
-    kind?: TOptions['kind']
+    post?: Array<string>
+    /**
+     * Options set for a specific plugin(see kubb.config.js), passthrough of options.
+     */
+    options: TOptions['resolvedOptions']
     /**
      * Define an api that can be used by other plugins, see `PluginManager' where we convert from `KubbUserPlugin` to `KubbPlugin`(used when calling `createPlugin`).
      */
@@ -257,11 +243,6 @@ export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
 export type KubbPluginWithLifeCycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = KubbPlugin<TOptions> & PluginLifecycle<TOptions>
 
 export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  /**
-   * Valdiate all plugins to see if their depended plugins are installed and configured.
-   * @type hookParallel
-   */
-  validate?: (this: Omit<PluginContext<TOptions>, 'addFile'>, plugins: NonNullable<KubbConfig['plugins']>) => PossiblePromise<true>
   /**
    * Start of the lifecycle of a plugin.
    * @type hookParallel

package/src/utils/FunctionParams.ts

@@ -1,6 +1,7 @@
-import { camelCase, camelCaseTransformMerge } from 'change-case'
 import { orderBy } from 'natural-orderby'
 
+import transformers from '../transformers/index.ts'
+
 type FunctionParamsASTWithoutType = {
   name?: string
   type?: string
@@ -66,7 +67,7 @@ export class FunctionParams {
           return acc
         }
         // TODO check whey we still need the camelcase here
-        const parameterName = name.startsWith('{') ? name : camelCase(name, { delimiter: '', transform: camelCaseTransformMerge })
+        const parameterName = name.startsWith('{') ? name : transformers.camelCase(name)
 
         if (type) {
           if (required) {

package/src/utils/TreeNode.ts

@@ -3,10 +3,13 @@ import dirTree from 'directory-tree'
 import { FileManager } from '../FileManager.ts'
 
 import type { DirectoryTree, DirectoryTreeOptions } from 'directory-tree'
+import type { KubbFile } from '../FileManager.ts'
 
 export type TreeNodeOptions = DirectoryTreeOptions
 
-export class TreeNode<T = unknown> {
+type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+
+export class TreeNode<T = BarrelData> {
   public data: T
 
   public parent?: TreeNode<T>
@@ -91,7 +94,7 @@ export class TreeNode<T = unknown> {
     return this
   }
 
-  public static build<T = unknown>(path: string, options: TreeNodeOptions = {}): TreeNode<T> | null {
+  public static build(path: string, options: TreeNodeOptions = {}): TreeNode | null {
     try {
       const exclude = Array.isArray(options.exclude) ? options.exclude : [options.exclude].filter(Boolean)
       const filteredTree = dirTree(path, { extensions: options.extensions, exclude: [/node_modules/, ...exclude] })
@@ -114,7 +117,7 @@ export class TreeNode<T = unknown> {
 
       filteredTree.children?.forEach((child) => recurse(treeNode, child))
 
-      return treeNode as TreeNode<T>
+      return treeNode
     } catch (e) {
       throw new Error('Something went wrong with creating index files with the TreehNode class', { cause: e })
     }