@kubb/core 2.0.0-alpha.9 → 2.0.0-beta.10

package/src/BarrelManager.ts

@@ -1,23 +1,28 @@
 import path from 'path'
 
+import transformers from './transformers/index.ts'
 import { TreeNode } from './utils/TreeNode.ts'
 
 import type { DirectoryTreeOptions } from 'directory-tree'
 import type { KubbFile } from './FileManager.ts'
+import type { KubbPlugin } from './index.ts'
 
-type BarrelData = { type: KubbFile.Mode; path: KubbFile.Path; name: string }
+type FileMeta = {
+  pluginKey?: KubbPlugin['key']
+  treeNode: TreeNode
+}
 
 export type BarrelManagerOptions = {
   treeNode?: DirectoryTreeOptions
   isTypeOnly?: boolean
-  filter?: (file: KubbFile.File) => boolean
-  map?: (file: KubbFile.File) => KubbFile.File
-  includeExt?: boolean
-  output?: string
+  /**
+   * Add .ts or .js
+   */
+  extName?: KubbFile.Extname
 }
 
 export class BarrelManager {
-  #options: BarrelManagerOptions = {}
+  #options: BarrelManagerOptions
 
   constructor(options: BarrelManagerOptions = {}) {
     this.#options = options
@@ -26,45 +31,34 @@ export class BarrelManager {
   }
 
   getIndexes(
-    root: string,
-    extName?: KubbFile.Extname,
-  ): Array<KubbFile.File> | null {
-    const { treeNode = {}, isTypeOnly, filter, map, output, includeExt } = this.#options
-
-    const extMapper: Record<KubbFile.Extname, DirectoryTreeOptions> = {
-      '.ts': {
-        extensions: /\.ts/,
-        exclude: [/schemas/, /json/],
-      },
-      '.json': {
-        extensions: /\.json/,
-        exclude: [],
-      },
-    }
-    const tree = TreeNode.build<BarrelData>(root, { ...(extMapper[extName as keyof typeof extMapper] || {}), ...treeNode })
+    pathToBuild: string,
+  ): Array<KubbFile.File<FileMeta>> | null {
+    const { treeNode = {}, isTypeOnly, extName } = this.#options
+    const tree = TreeNode.build(pathToBuild, treeNode)
 
     if (!tree) {
       return null
     }
 
-    const fileReducer = (files: Array<KubbFile.File>, currentTree: typeof tree) => {
-      if (!currentTree.children) {
+    const fileReducer = (files: Array<KubbFile.File<FileMeta>>, treeNode: TreeNode) => {
+      if (!treeNode.children) {
         return []
       }
 
-      if (currentTree.children?.length > 1) {
-        const indexPath: KubbFile.Path = path.resolve(currentTree.data.path, 'index.ts')
-        const exports: KubbFile.Export[] = currentTree.children
+      if (treeNode.children.length > 1) {
+        const indexPath: KubbFile.Path = path.resolve(treeNode.data.path, 'index.ts')
+
+        const exports: KubbFile.Export[] = treeNode.children
           .filter(Boolean)
           .map((file) => {
-            const importPath: string = file.data.type === 'directory' ? `./${file.data.name}/index` : `./${file.data.name.replace(/\.[^.]*$/, '')}`
+            const importPath: string = file.data.type === 'directory' ? `./${file.data.name}/index` : `./${transformers.trimExtName(file.data.name)}`
 
-            if (importPath.includes('index') && file.data.type === 'file') {
+            if (importPath.endsWith('index') && file.data.type === 'file') {
               return undefined
             }
 
             return {
-              path: includeExt ? `${importPath}${extName}` : importPath,
+              path: extName ? `${importPath}${extName}` : importPath,
               isTypeOnly,
             } as KubbFile.Export
           })
@@ -74,50 +68,46 @@ export class BarrelManager {
           path: indexPath,
           baseName: 'index.ts',
           source: '',
-          exports: output
-            ? exports?.filter((item) => {
-              return item.path.endsWith(output.replace(/\.[^.]*$/, ''))
-            })
-            : exports,
+          exports,
+          meta: {
+            treeNode,
+          },
         })
-      } else {
-        currentTree.children?.forEach((child) => {
-          const indexPath = path.resolve(currentTree.data.path, 'index.ts')
-          const importPath = child.data.type === 'directory' ? `./${child.data.name}/index` : `./${child.data.name.replace(/\.[^.]*$/, '')}`
-
-          const exports = [
-            {
-              path: includeExt
-                ? `${importPath}${extName}`
-                : importPath,
-              isTypeOnly,
-            },
-          ]
-
-          files.push({
-            path: indexPath,
-            baseName: 'index.ts',
-            source: '',
-            exports: output
-              ? exports?.filter((item) => {
-                return item.path.endsWith(output.replace(/\.[^.]*$/, ''))
-              })
-              : exports,
-          })
+      } else if (treeNode.children.length === 1) {
+        const [treeNodeChild] = treeNode.children as [TreeNode]
+
+        const indexPath = path.resolve(treeNode.data.path, 'index.ts')
+        const importPath = treeNodeChild.data.type === 'directory'
+          ? `./${treeNodeChild.data.name}/index`
+          : `./${transformers.trimExtName(treeNodeChild.data.name)}`
+
+        const exports = [
+          {
+            path: extName
+              ? `${importPath}${extName}`
+              : importPath,
+            isTypeOnly,
+          },
+        ]
+
+        files.push({
+          path: indexPath,
+          baseName: 'index.ts',
+          source: '',
+          exports,
+          meta: {
+            treeNode,
+          },
         })
       }
 
-      currentTree.children.forEach((childItem) => {
+      treeNode.children.forEach((childItem) => {
         fileReducer(files, childItem)
       })
 
       return files
     }
 
-    const files = fileReducer([], tree).reverse()
-
-    const filteredFiles = filter ? files.filter(filter) : files
-
-    return map ? filteredFiles.map(map) : filteredFiles
+    return fileReducer([], tree).reverse()
   }
 }

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'
 
@@ -26,38 +26,53 @@ export namespace KubbFile {
     /**
      * Import name to be used
      * @example ["useState"]
-     * @examples "React"
+     * @example "React"
      */
-    name: string | Array<string>
+    name:
+      | string
+      | Array<
+        string | {
+          propertyName: string
+          name?: string
+        }
+      >
     /**
      * Path for the import
      * @xample '@kubb/core'
      */
     path: string
     /**
-     * Add `type` prefix to the import, this will result in: `import type { Type } from './path'`
+     * 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 = {
     /**
-     * Export name to be used
+     * Export name to be used.
      * @example ["useState"]
-     * @examples "React"
+     * @example "React"
      */
     name?: string | Array<string>
     /**
-     * Path for the import
+     * Path for the import.
      * @xample '@kubb/core'
      */
     path: string
     /**
-     * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`
+     * Add `type` prefix to the export, this will result in: `export type { Type } from './path'`.
      */
     isTypeOnly?: boolean
     /**
-     * Make it possible to override the name, this will result in: `export * as aliasName from './path'`
+     * Make it possible to override the name, this will result in: `export * as aliasName from './path'`.
      */
     asAlias?: boolean
   }
@@ -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`,
         )
       }
 
@@ -308,27 +308,11 @@ export class PluginManager {
     hookName: H
     parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined
   }): Promise<Awaited<TOuput>[]> {
-    const parallelPromises: Promise<TOuput>[] = []
+    const promises = this.#getSortedPlugins().map((plugin) => {
+      return () => this.#execute({ strategy: 'hookParallel', hookName, parameters, plugin }) as Promise<TOuput>
+    })
 
-    for (const plugin of this.#getSortedPlugins()) {
-      // TODO implement sequential with `buildStart` as an object({ sequential: boolean; handler: PluginContext["buildStart"] })
-      // if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
-      //   await Promise.all(parallelPromises)
-      //   parallelPromises.length = 0
-      //   await this.execute({
-      //     strategy: 'hookParallel',
-      //     hookName,
-      //     parameters,
-      //     plugin,
-      //   })
-      // }
-      const promise: Promise<TOuput> | null = this.#execute({ strategy: 'hookParallel', hookName, parameters, plugin }) as Promise<TOuput>
-
-      if (promise) {
-        parallelPromises.push(promise)
-      }
-    }
-    const results = await Promise.allSettled(parallelPromises)
+    const results = await this.#promiseManager.run('parallel', promises)
 
     results
       .forEach((result, index) => {
@@ -338,7 +322,7 @@ export class PluginManager {
           this.#catcher<H>(result.reason, plugin, hookName)
         }
       })
-    // TODO replace by promiseManager
+
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
 
@@ -370,7 +354,7 @@ export class PluginManager {
         })
         .then((result) => reduce.call(this.#core.api, argument0, result as ReturnType<ParseResult<H>>, plugin)) as Promise<Argument0<H>>
     }
-    // TODO replace by promiseManager
+
     return promise
   }
 
@@ -395,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`)
@@ -404,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) {
@@ -433,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 {
@@ -585,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')
@@ -640,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/PromiseManager.ts

@@ -1,4 +1,4 @@
-import { hookFirst, hookSeq } from './utils/executeStrategies.ts'
+import { hookFirst, hookParallel, hookSeq } from './utils/executeStrategies.ts'
 
 import type { PossiblePromise } from '@kubb/types'
 import type { Strategy, StrategySwitch } from './utils/executeStrategies.ts'
@@ -30,6 +30,10 @@ export class PromiseManager<TState = any> {
       return hookFirst<TInput, TValue, TOutput>(promises, this.#options.nullCheck)
     }
 
+    if (strategy === 'parallel') {
+      return hookParallel<TInput, TValue, TOutput>(promises)
+    }
+
     throw new Error(`${strategy} not implemented`)
   }
 }

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 {}