@kubb/core 3.0.0-alpha.9 → 3.0.0-beta.2

package/src/build.ts

@@ -6,10 +6,10 @@ import { isInputPath } from './config.ts'
 import { createLogger } from './logger.ts'
 import { URLPath } from './utils/URLPath.ts'
 
-import { resolve } from 'node:path'
+import { join, resolve } from 'node:path'
 import { getRelativePath } from '@kubb/fs'
 import type { Logger } from './logger.ts'
-import type { PluginContext } from './types.ts'
+import type { Output, PluginContext } from './types.ts'
 
 type BuildOptions = {
   config: PluginContext['config']
@@ -45,6 +45,7 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
 
   if (config.output.clean) {
     await clean(config.output.path)
+    await clean(join(config.root, '.kubb'))
   }
 
   return new PluginManager(config, { logger })
@@ -63,13 +64,25 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 }
 
 export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
-  const pluginManager = await setup(options)
   let files = []
+  const pluginManager = await setup(options)
 
   try {
+    pluginManager.events.on('executing', ({ plugin, message }) => {
+      pluginManager.logger.emit('debug', { date: new Date(), logs: [`Executing pluginKey ${plugin.key?.join('.')} | ${message}`] })
+    })
+
+    pluginManager.events.on('executed', ({ plugin, message, output }) => {
+      pluginManager.logger.emit('debug', {
+        date: new Date(),
+        logs: [`Executed pluginKey ${plugin.key?.join('.')} | ${message} |  ${JSON.stringify(output, undefined, 2)}`],
+      })
+    })
+
     await pluginManager.hookParallel({
       hookName: 'buildStart',
       parameters: [options.config],
+      message: 'buildStart',
     })
 
     // create root barrel file
@@ -91,20 +104,21 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
               }
 
               // validate of the file is coming from plugin x, needs pluginKey on every file TODO update typing
-              const plugin = pluginManager.plugins.find((item) => {
+              const plugin = [...pluginManager.plugins].find((item) => {
                 const meta = file.meta as any
-                return item.name === meta?.pluginKey?.[0]
+                return item.key === meta?.pluginKey
               })
+              const pluginOptions = (plugin?.options as { output?: Output }) ?? {}
 
-              if (plugin?.output?.exportType === false) {
+              if (pluginOptions.output?.barrelType === false) {
                 return undefined
               }
 
-              if (FileManager.getMode(plugin?.output?.path) === 'single') {
+              if (FileManager.getMode(pluginOptions.output?.path) === 'single') {
                 return undefined
               }
               return {
-                name: options.config.output.exportType === 'barrel' ? undefined : [source.name],
+                name: pluginOptions.output?.barrelType === 'all' ? undefined : [source.name],
                 path: getRelativePath(rootPath, file.path),
                 isTypeOnly: source.isTypeOnly,
               } as KubbFile.Export
@@ -116,11 +130,10 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       meta: {},
     }
 
-    if (options.config.output.exportType) {
+    if (options.config.output.barrelType) {
       await pluginManager.fileManager.add(rootFile)
     }
 
-    //TODO set extName here instead of the files, extName is private. All exports will have extName, it's up the the process to hide.override the name
     files = await processFiles({
       config: options.config,
       dryRun: !options.config.output.write,
@@ -128,7 +141,7 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
       logger: pluginManager.logger,
     })
 
-    await pluginManager.hookParallel({ hookName: 'buildEnd' })
+    await pluginManager.hookParallel({ hookName: 'buildEnd', message: `Build stopped for ${options.config.name}` })
 
     pluginManager.fileManager.clear()
   } catch (e) {

package/src/config.ts

@@ -29,9 +29,7 @@ type Args = {
 }
 
 /**
- * Type helper to make it easier to use kubb.config.js
- * accepts a direct {@link Config} object, or a function that returns it.
- * The function receives a {@link ConfigEnv} object that exposes two properties:
+ * Type helper to make it easier to use vite.config.ts accepts a direct UserConfig object, or a function that returns it. The function receives a ConfigEnv object.
  */
 export function defineConfig(
   options:
@@ -45,5 +43,5 @@ export function defineConfig(
 }
 
 export function isInputPath(result: Config | undefined): result is Config<InputPath> {
-  return !!result && 'path' in (result as any)
+  return !!result && 'path' in (result?.input as any)
 }

package/src/index.ts

@@ -1,6 +1,6 @@
 export { build, build as default, safeBuild } from './build.ts'
 export { defineConfig, isInputPath } from './config.ts'
-export { FileManager } from './FileManager.ts'
+export { FileManager, getSource } from './FileManager.ts'
 export type { FileMetaBase } from './FileManager.ts'
 export { BaseGenerator } from './BaseGenerator.ts'
 export { PackageManager } from './PackageManager.ts'

package/src/logger.ts

@@ -3,19 +3,22 @@ import c, { createColors } from 'tinyrainbow'
 
 import { EventEmitter } from './utils/EventEmitter.ts'
 
-import type * as KubbFile from '@kubb/fs/src/types.ts'
+import { resolve } from 'node:path'
+import { write } from '@kubb/fs'
 import { type ConsolaInstance, type LogLevel, createConsola } from 'consola'
 import type { Formatter } from 'tinyrainbow'
 
+type DebugEvent = { date: Date; logs: string[]; fileName?: string }
+
 type Events = {
   start: [message: string]
   success: [message: string]
   error: [message: string, cause: Error]
   warning: [message: string]
-  debug: [{ logs: string[]; override?: boolean; fileName?: string }]
+  debug: [DebugEvent]
   info: [message: string]
-  progress_start: [{ id: string; size: number }]
-  progress: [{ id: string; count?: number; data?: string }]
+  progress_start: [{ id: string; size: number; message?: string }]
+  progressed: [{ id: string; message?: string }]
   progress_stop: [{ id: string }]
 }
 
@@ -34,6 +37,7 @@ export type Logger = {
   consola?: ConsolaInstance
   on: EventEmitter<Events>['on']
   emit: EventEmitter<Events>['emit']
+  writeLogs: () => Promise<string[]>
 }
 
 type Props = {
@@ -44,6 +48,8 @@ type Props = {
 
 export function createLogger({ logLevel = 3, name, consola: _consola }: Props = {}): Logger {
   const events = new EventEmitter<Events>()
+  const startDate = Date.now()
+  const cachedLogs = new Set<DebugEvent>()
 
   const consola =
     _consola ||
@@ -52,7 +58,7 @@ export function createLogger({ logLevel = 3, name, consola: _consola }: Props =
       formatOptions: {
         colors: true,
         date: true,
-        columns: 120,
+        columns: 80,
         compact: logLevel !== LogMapper.debug,
       },
     }).withTag(name ? randomCliColour(name) : '')
@@ -75,6 +81,14 @@ export function createLogger({ logLevel = 3, name, consola: _consola }: Props =
     consola.info(c.yellow(message))
   })
 
+  events.on('debug', (message) => {
+    if (message.logs.join('\n\n').length <= 100 && logLevel === LogMapper.debug) {
+      console.log(message.logs.join('\n\n'))
+    }
+
+    cachedLogs.add(message)
+  })
+
   events.on('error', (message, cause) => {
     const error = new Error(message || 'Something went wrong')
     error.cause = cause
@@ -90,12 +104,32 @@ export function createLogger({ logLevel = 3, name, consola: _consola }: Props =
     name,
     logLevel,
     consola,
-    on: (...args) => {
+    on(...args) {
       return events.on(...args)
     },
-    emit: (...args) => {
+    emit(...args) {
       return events.emit(...args)
     },
+    async writeLogs() {
+      const files: Record<string, string[]> = {}
+
+      cachedLogs.forEach((log) => {
+        const fileName = resolve(process.cwd(), '.kubb', log.fileName || `kubb-${startDate}.log`)
+
+        if (!files[fileName]) {
+          files[fileName] = []
+        }
+
+        files[fileName] = [...files[fileName], `[${log.date.toLocaleString()}]: ${log.logs.join('\n\n')}`]
+      })
+      await Promise.all(
+        Object.entries(files).map(async ([fileName, logs]) => {
+          return write(fileName, logs.join('\n'))
+        }),
+      )
+
+      return Object.keys(files)
+    },
   }
 
   return logger

package/src/plugin.ts

@@ -1,7 +1,5 @@
 import path from 'node:path'
 
-import { createPluginCache } from './utils/cache.ts'
-
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Plugin, PluginContext, PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
@@ -63,7 +61,6 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
         },
         resolvePath,
         resolveName,
-        cache: createPluginCache(),
       }
     },
     resolvePath(baseName) {

package/src/transformers/escape.ts

@@ -29,13 +29,3 @@ export function jsStringEscape(input: any): string {
     }
   })
 }
-
-export function escapeStringRegexp(string: string) {
-  if (typeof string !== 'string') {
-    throw new TypeError('Expected a string')
-  }
-
-  // Escape characters with special meaning either inside or outside character sets.
-  // Use a simple backslash escape when it’s always valid, and a `\xnn` escape when the simpler form would be disallowed by Unicode patterns’ stricter grammar.
-  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d')
-}

package/src/transformers/stringify.ts

@@ -1,6 +1,6 @@
 import { trimQuotes } from './trim'
 
-export function stringify(value: string | number | undefined): string {
+export function stringify(value: string | number | boolean | undefined): string {
   if (value === undefined || value === null) {
     return '""'
   }

package/src/types.ts

@@ -3,7 +3,6 @@ import type { PossiblePromise } from '@kubb/types'
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Logger } from './logger.ts'
-import type { Cache } from './utils/cache.ts'
 
 // config
 
@@ -30,20 +29,22 @@ export type UserConfig = Omit<Config, 'root' | 'plugins'> & {
 
 export type InputPath = {
   /**
-   * Path to be used as the input. This can be an absolute path or a path relative to the `root`.
+   * Define your Swagger/OpenAPI file. This can be an absolute path or a path relative to the `root`.
    */
   path: string
 }
 
 export type InputData = {
   /**
-   * `string` or `object` containing the data.
+   * `string` or `object` containing your Swagger/OpenAPI data.
    */
   data: string | unknown
 }
 
 type Input = InputPath | InputData
 
+export type BarrelType = 'all' | 'named'
+
 /**
  * @private
  */
@@ -53,38 +54,44 @@ export type Config<TInput = Input> = {
    */
   name?: string
   /**
-   * Project root directory. Can be an absolute path, or a path relative from
-   * the location of the config file itself.
+   * Project root directory. This can be an absolute path or a path relative to the location of your `kubb.config.ts` file.
    * @default process.cwd()
    */
   root: string
+  /**
+   * You can use `input.path` or `input.data` depending on the needs you have.
+   */
   input: TInput
   output: {
     /**
-     * Path to be used to export all generated files.
-     * This can be an absolute path, or a path relative based of the defined `root` option.
+     * The path where all generated files will be exported. This can be an absolute path or a path relative to the specified root option.
      */
     path: string
     /**
-     * Clean output directory before each build.
+     * Clean the output directory before each build.
      */
     clean?: boolean
     /**
-     * Write files to the fileSystem
-     * This is being used for the playground.
+     * Save files to the file system.
      * @default true
      */
     write?: boolean
+
+    /**
+     * Override the extension to the generated imports and exports, by default the plugin will add an extension
+     * @default `{ '.ts': '.ts'}`
+     */
+    extension?: Record<KubbFile.Extname, KubbFile.Extname>
     /**
-     * Define what needs to exported, here you can also disable the export of barrel files
-     * @default `'barrelNamed'`
+     * Define what needs to exported, here you can also disable the export of barrel files.
+     * @default `'named'`
      */
-    exportType?: 'barrel' | 'barrelNamed' | false
+    barrelType?: BarrelType | false
   }
   /**
-   * Array of Kubb plugins to use.
-   * The plugin/package can forsee some options that you need to pass through.
-   * Sometimes a plugin is depended on another plugin, if that's the case you will get an error back from the plugin you installed.
+   * An array of Kubb plugins that will be used in the generation.
+   * Each plugin may include additional configurable options(defined in the plugin itself).
+   * If a plugin depends on another plugin, an error will be returned if the required dependency is missing. See pre for more details.
    */
   plugins?: Array<Plugin>
   /**
@@ -181,21 +188,6 @@ export type Plugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>
    * @private
    */
   key: TOptions['key']
-  output?: {
-    /**
-     * Output to save the clients.
-     */
-    path: string
-    /**
-     * Add an extension to the generated imports and exports, default it will not use an extension
-     */
-    extName?: KubbFile.Extname
-    /**
-     * Define what needs to exported, here you can also disable the export of barrel files
-     * @default `'barrelNamed'`
-     */
-    exportType?: 'barrel' | 'barrelNamed' | false
-  }
   /**
    * 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 dependent plugins.
@@ -234,7 +226,12 @@ export type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactor
    * @type hookFirst
    * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
    */
-  resolvePath?: (this: PluginContext<TOptions>, baseName: string, mode?: KubbFile.Mode, options?: TOptions['resolvePathOptions']) => KubbFile.OptionalPath
+  resolvePath?: (
+    this: PluginContext<TOptions>,
+    baseName: KubbFile.BaseName,
+    mode?: KubbFile.Mode,
+    options?: TOptions['resolvePathOptions'],
+  ) => KubbFile.OptionalPath
   /**
    * Resolve to a name based on a string.
    * Useful when converting to PascalCase or camelCase.
@@ -253,11 +250,9 @@ export type PluginLifecycleHooks = keyof PluginLifecycle
 
 export type PluginParameter<H extends PluginLifecycleHooks> = Parameters<Required<PluginLifecycle>[H]>
 
-export type PluginCache = Record<string, [number, unknown]>
-
 export type ResolvePathParams<TOptions = object> = {
   pluginKey?: Plugin['key']
-  baseName: string
+  baseName: KubbFile.BaseName
   mode?: KubbFile.Mode
   /**
    * Options to be passed to 'resolvePath' 3th parameter
@@ -270,15 +265,15 @@ export type ResolveNameParams = {
   pluginKey?: Plugin['key']
   /**
    * `file` will be used to customize the name of the created file(use of camelCase)
-   * `function` can be used used to customize the exported functions(use of camelCase)
+   * `function` can be used to customize the exported functions(use of camelCase)
    * `type` is a special type for TypeScript(use of PascalCase)
+   * `const` can be used for variables(use of camelCase)
    */
-  type?: 'file' | 'function' | 'type'
+  type?: 'file' | 'function' | 'type' | 'const'
 }
 
 export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
   config: Config
-  cache: Cache<PluginCache>
   fileManager: FileManager
   pluginManager: PluginManager
   addFile: (...file: Array<KubbFile.File>) => Promise<Array<KubbFile.ResolvedFile>>
@@ -294,3 +289,40 @@ export type PluginContext<TOptions extends PluginFactoryOptions = PluginFactoryO
    */
   plugin: Plugin<TOptions>
 }
+/**
+ * Specify the export location for the files and define the behavior of the output
+ */
+export type Output = {
+  /**
+   * Path to the output folder or file that will contain the generated code
+   */
+  path: string
+  /**
+   * Define what needs to be exported, here you can also disable the export of barrel files
+   * @default `'named'`
+   */
+  barrelType?: BarrelType | false
+  /**
+   * Add a banner text in the beginning of every file
+   */
+  banner?: string
+  /**
+   * Add a footer text in the beginning of every file
+   */
+  footer?: string
+}
+
+type GroupContext = {
+  group: string
+}
+
+export type Group = {
+  /**
+   * Define a type where to group the files on
+   */
+  type: 'tag'
+  /**
+   * Return the name of a group based on the group name, this will be used for the file and name generation
+   */
+  name?: (context: GroupContext) => string
+}

package/src/utils/TreeNode.ts

@@ -12,11 +12,10 @@ type BarrelData = {
 }
 
 export class TreeNode {
-  public data: BarrelData
-
-  public parent?: TreeNode
-
-  public children: Array<TreeNode> = []
+  data: BarrelData
+  parent?: TreeNode
+  children: Array<TreeNode> = []
+  #cachedLeaves?: Array<TreeNode> = undefined
 
   constructor(data: BarrelData, parent?: TreeNode) {
     this.data = data
@@ -33,25 +32,11 @@ export class TreeNode {
     return child
   }
 
-  find(data?: BarrelData): TreeNode | null {
-    if (!data) {
-      return null
-    }
-
-    if (data === this.data) {
+  get root(): TreeNode {
+    if (!this.parent) {
       return this
     }
-
-    if (this.children?.length) {
-      for (let i = 0, { length } = this.children, target: TreeNode | null = null; i < length; i++) {
-        target = this.children[i]!.find(data)
-        if (target) {
-          return target
-        }
-      }
-    }
-
-    return null
+    return this.parent.root
   }
 
   get leaves(): Array<TreeNode> {
@@ -60,6 +45,10 @@ export class TreeNode {
       return [this]
     }
 
+    if (this.#cachedLeaves) {
+      return this.#cachedLeaves
+    }
+
     // if not a leaf, return all children's leaves recursively
     const leaves: TreeNode[] = []
     if (this.children) {
@@ -67,14 +56,10 @@ export class TreeNode {
         leaves.push.apply(leaves, this.children[i]!.leaves)
       }
     }
-    return leaves
-  }
 
-  get root(): TreeNode {
-    if (!this.parent) {
-      return this
-    }
-    return this.parent.root
+    this.#cachedLeaves = leaves
+
+    return leaves
   }
 
   forEach(callback: (treeNode: TreeNode) => void): this {
@@ -95,46 +80,36 @@ export class TreeNode {
     return this
   }
 
-  filter(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
-    let data: Array<TreeNode> = []
-    if (typeof callback !== 'function') {
-      throw new TypeError('forEach() callback must be a function')
+  findDeep(predicate?: (value: TreeNode, index: number, obj: TreeNode[]) => boolean): TreeNode | undefined {
+    if (typeof predicate !== 'function') {
+      throw new TypeError('find() predicate must be a function')
     }
 
-    // run this node through function
-    if (callback(this)) {
-      data.push(this)
-    }
+    return this.leaves.find(predicate)
+  }
 
-    // do the same for all children
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        const childData = this.children[i]?.filter(callback).filter(Boolean) || []
-        data = [...new Set([...data, ...childData])]
-      }
+  forEachDeep(callback: (treeNode: TreeNode) => void): void {
+    if (typeof callback !== 'function') {
+      throw new TypeError('forEach() callback must be a function')
     }
 
-    return data
+    this.leaves.forEach(callback)
   }
 
-  map<T>(callback: (treeNode: TreeNode) => T): Array<T> {
-    let data: Array<T> = []
+  filterDeep(callback: (treeNode: TreeNode) => boolean): Array<TreeNode> {
     if (typeof callback !== 'function') {
-      throw new TypeError('forEach() callback must be a function')
+      throw new TypeError('filter() callback must be a function')
     }
 
-    // run this node through function
-    data.push(callback(this))
+    return this.leaves.filter(callback)
+  }
 
-    // do the same for all children
-    if (this.children) {
-      for (let i = 0, { length } = this.children; i < length; i++) {
-        const childData = this.children[i]?.map(callback).filter(Boolean) || []
-        data = [...new Set([...data, ...childData])]
-      }
+  mapDeep<T>(callback: (treeNode: TreeNode) => T): Array<T> {
+    if (typeof callback !== 'function') {
+      throw new TypeError('map() callback must be a function')
     }
 
-    return data
+    return this.leaves.map(callback)
   }
 
   public static build(files: KubbFile.File[], root?: string): TreeNode | null {

package/src/utils/executeStrategies.ts

@@ -1,8 +1,8 @@
 type PromiseFunc<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2
 
-export type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
+type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc<infer X, infer Y>> ? X | Y : never
 
-export function noReturn(): void {}
+function noReturn(): void {}
 
 type SeqOutput<TInput extends Array<PromiseFunc<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>