@kubb/core 1.0.0 → 1.0.2

package/src/managers/pluginManager/PluginManager.ts

@@ -1,15 +1,19 @@
+/* eslint-disable @typescript-eslint/ban-types */
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-restricted-syntax */
 
-import { definePlugin } from '../../plugin'
-import { FileManager } from '../fileManager'
-import { Queue } from '../../utils/Queue'
+import { PluginError } from './PluginError.ts'
+import { ParallelPluginError } from './ParallelPluginError.ts'
 
-import type { QueueTask } from '../../utils/Queue'
-import type { Argument0, Strategy } from './types'
-import type { KubbConfig, KubbPlugin, PluginLifecycleHooks, PluginLifecycle, MaybePromise, ResolvePathParams, ResolveNameParams } from '../../types'
-import type { Logger } from '../../build'
-import type { CorePluginOptions } from '../../plugin'
+import { definePlugin } from '../../plugin.ts'
+import { FileManager } from '../fileManager/FileManager.ts'
+import { Queue } from '../../utils/Queue.ts'
+import { isPromise } from '../../utils/isPromise.ts'
+
+import type { QueueTask } from '../../utils/Queue.ts'
+import type { Argument0, Strategy, Executer, OnExecute } from './types.ts'
+import type { KubbConfig, KubbPlugin, PluginLifecycleHooks, PluginLifecycle, MaybePromise, ResolvePathParams, ResolveNameParams } from '../../types.ts'
+import type { CorePluginOptions } from '../../plugin.ts'
 
 // inspired by: https://github.com/rollup/rollup/blob/master/src/utils/PluginDriver.ts#
 
@@ -28,22 +32,25 @@ const hookNames: {
 }
 export const hooks = Object.keys(hookNames) as [PluginLifecycleHooks]
 
+type Options = { task: QueueTask; onExecute?: OnExecute<PluginLifecycleHooks> }
+
 export class PluginManager {
   public plugins: KubbPlugin[]
 
   public readonly fileManager: FileManager
 
-  private readonly logger?: Logger
-
-  private readonly config: KubbConfig
+  private readonly onExecute?: OnExecute
 
   public readonly core: KubbPlugin<CorePluginOptions>
 
   public queue: Queue
 
-  constructor(config: KubbConfig, options: { logger?: Logger; task: QueueTask }) {
-    this.logger = options.logger
-    this.config = config
+  public executer: Executer | undefined
+
+  public executed: Executer[] = []
+
+  constructor(config: KubbConfig, options: Options) {
+    this.onExecute = options.onExecute
     this.queue = new Queue(10)
 
     this.fileManager = new FileManager({ task: options.task, queue: this.queue })
@@ -53,12 +60,17 @@ export class PluginManager {
       load: this.load,
       resolvePath: this.resolvePath,
       resolveName: this.resolveName,
+      getExecuter: this.getExecuter.bind(this),
     }) as KubbPlugin<CorePluginOptions> & {
       api: CorePluginOptions['api']
     }
     this.plugins = [this.core, ...(config.plugins || [])]
   }
 
+  getExecuter() {
+    return this.executer
+  }
+
   resolvePath = (params: ResolvePathParams) => {
     if (params.pluginName) {
       return this.hookForPluginSync({
@@ -106,10 +118,10 @@ export class PluginManager {
     pluginName: string
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
-  }): Promise<ReturnType<PluginLifecycle[H]> | null> {
+  }): Promise<ReturnType<PluginLifecycle[H]> | null> | null {
     const plugin = this.getPlugin(hookName, pluginName)
 
-    return this.run({
+    return this.execute({
       strategy: 'hookFirst',
       hookName,
       parameters,
@@ -125,10 +137,10 @@ export class PluginManager {
     pluginName: string
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
-  }): ReturnType<PluginLifecycle[H]> {
+  }): ReturnType<PluginLifecycle[H]> | null {
     const plugin = this.getPlugin(hookName, pluginName)
 
-    return this.runSync({
+    return this.executeSync({
       strategy: 'hookFirst',
       hookName,
       parameters,
@@ -154,7 +166,7 @@ export class PluginManager {
       if (skipped && skipped.has(plugin)) continue
       promise = promise.then((result) => {
         if (result != null) return result
-        return this.run({
+        return this.execute({
           strategy: 'hookFirst',
           hookName,
           parameters,
@@ -183,7 +195,7 @@ export class PluginManager {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin)) continue
 
-      result = this.runSync<H>({
+      result = this.executeSync<H>({
         strategy: 'hookFirst',
         hookName,
         parameters,
@@ -211,19 +223,28 @@ export class PluginManager {
       if ((plugin[hookName] as { sequential?: boolean })?.sequential) {
         await Promise.all(parallelPromises)
         parallelPromises.length = 0
-        await this.run({
+        await this.execute({
           strategy: 'hookParallel',
           hookName,
           parameters,
           plugin,
         })
       } else {
-        const promise: Promise<TOuput> = this.run({ strategy: 'hookParallel', hookName, parameters, plugin })
+        const promise: Promise<TOuput> | null = this.execute({ strategy: 'hookParallel', hookName, parameters, plugin })
 
-        parallelPromises.push(promise)
+        if (promise) {
+          parallelPromises.push(promise)
+        }
       }
     }
-    return Promise.all(parallelPromises)
+    const results = await Promise.allSettled(parallelPromises)
+    const errors = results.filter((result) => result.status === 'rejected').map((result) => (result as PromiseRejectedResult).reason) as PluginError[]
+
+    if (errors.length) {
+      throw new ParallelPluginError('Error', { errors, pluginManager: this })
+    }
+
+    return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
 
   // chains, reduces returned value, handling the reduced value as the first hook argument
@@ -240,14 +261,17 @@ export class PluginManager {
 
     let promise: Promise<Argument0<H>> = Promise.resolve(argument0)
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then((argument0) =>
-        this.run({
-          strategy: 'hookReduceArg0',
-          hookName,
-          parameters: [argument0, ...rest] as Parameters<PluginLifecycle[H]>,
-          plugin,
-        }).then((result) => reduce.call(this.core.api, argument0, result as ReturnType<PluginLifecycle[H]>, plugin))
-      ) as Promise<Argument0<H>>
+      promise = promise
+        .then((argument0) => {
+          const value = this.execute({
+            strategy: 'hookReduceArg0',
+            hookName,
+            parameters: [argument0, ...rest] as Parameters<PluginLifecycle[H]>,
+            plugin,
+          })
+          return value
+        })
+        .then((result) => reduce.call(this.core.api, argument0, result as ReturnType<PluginLifecycle[H]>, plugin)) as Promise<Argument0<H>>
     }
     return promise
   }
@@ -255,10 +279,10 @@ export class PluginManager {
   // chains
 
   hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: Parameters<PluginLifecycle[H]> }) {
-    let promise: Promise<void> = Promise.resolve()
+    let promise: Promise<void | null> = Promise.resolve()
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(() =>
-        this.run({
+        this.execute({
           strategy: 'hookSeq',
           hookName,
           parameters,
@@ -281,14 +305,20 @@ export class PluginManager {
     const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName])
     if (!pluginByPluginName) {
       // fallback on the core plugin when there is no match
-      if (this.config.logLevel === 'warn' && this.logger?.spinner) {
-        this.logger.spinner.info(`Plugin hook with ${hookName} not found for plugin ${pluginName}`)
-      }
+
       return this.core
     }
     return pluginByPluginName
   }
 
+  private addExecuter(executer: Executer | undefined) {
+    this.onExecute?.call(this, executer)
+
+    if (executer) {
+      this.executed.push(executer)
+    }
+  }
+
   /**
    * Run an async plugin hook and return the result.
    * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
@@ -296,7 +326,7 @@ export class PluginManager {
    * @param plugin The actual pluginObject to run.
    */
   // Implementation signature
-  private run<H extends PluginLifecycleHooks, TResult = void>({
+  private execute<H extends PluginLifecycleHooks, TResult = void>({
     strategy,
     hookName,
     parameters,
@@ -306,36 +336,47 @@ export class PluginManager {
     hookName: H
     parameters: unknown[] | undefined
     plugin: KubbPlugin
-  }): Promise<TResult> {
-    const hook = plugin[hookName]!
+  }): Promise<TResult> | null {
+    const hook = plugin[hookName]
+
+    if (!hook) {
+      return null
+    }
 
     return Promise.resolve()
       .then(() => {
-        if (typeof hook !== 'function') {
-          return hook
+        // add current execution to the variable `this.executer` so we can track which plugin is getting called
+        this.executer = {
+          strategy,
+          hookName,
+          plugin,
         }
 
-        if (this.config.logLevel === 'info' && this.logger?.spinner) {
-          this.logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} \n`
-        }
+        if (typeof hook === 'function') {
+          const hookResult = (hook as Function).apply(this.core.api, parameters)
 
-        const hookResult = (hook as Function).apply(this.core.api, parameters)
+          if (isPromise(hookResult)) {
+            return Promise.resolve(hookResult).then((result) => {
+              this.addExecuter({
+                strategy,
+                hookName,
+                plugin,
+              })
 
-        if (!(hookResult as Promise<unknown>)?.then) {
-          // short circuit for non-thenables and non-Promises
-          if (this.config.logLevel === 'info' && this.logger?.spinner) {
-            this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} \n`)
+              return result
+            })
           }
+
           return hookResult
         }
 
-        return Promise.resolve(hookResult).then((result) => {
-          // action was fulfilled
-          if (this.config.logLevel === 'info' && this.logger?.spinner) {
-            this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} \n`)
-          }
-          return result
+        this.addExecuter({
+          strategy,
+          hookName,
+          plugin,
         })
+
+        return hook
       })
       .catch((e: Error) => {
         this.catcher<H>(e, plugin, hookName)
@@ -349,7 +390,7 @@ export class PluginManager {
    * @param plugin The acutal plugin
    * @param replaceContext When passed, the plugin context can be overridden.
    */
-  private runSync<H extends PluginLifecycleHooks>({
+  private executeSync<H extends PluginLifecycleHooks>({
     strategy,
     hookName,
     parameters,
@@ -359,20 +400,44 @@ export class PluginManager {
     hookName: H
     parameters: Parameters<PluginLifecycle[H]>
     plugin: KubbPlugin
-  }): ReturnType<PluginLifecycle[H]> {
-    const hook = plugin[hookName]!
+  }): ReturnType<PluginLifecycle[H]> | null {
+    const hook = plugin[hookName]
 
-    // const context = this.pluginContexts.get(plugin)!;
+    if (!hook) {
+      return null
+    }
 
     try {
+      // add current execution to the variable `this.executer` so we can track which plugin is getting called
+      this.executer = {
+        strategy,
+        hookName,
+        plugin,
+      }
+
       // eslint-disable-next-line @typescript-eslint/ban-types
-      if (typeof hook !== 'function') {
-        return hook
+      if (typeof hook === 'function') {
+        const fn = (hook as Function).apply(this.core.api, parameters)
+
+        this.addExecuter({
+          strategy,
+          hookName,
+          plugin,
+        })
+
+        return fn
       }
 
-      return (hook as Function).apply(this.core.api, parameters)
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin,
+      })
+
+      return hook
     } catch (e) {
       this.catcher<H>(e as Error, plugin, hookName)
+
       return null as ReturnType<PluginLifecycle[H]>
     }
   }
@@ -380,7 +445,7 @@ export class PluginManager {
   private catcher<H extends PluginLifecycleHooks>(e: Error, plugin: KubbPlugin, hookName: H) {
     const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})\n`
 
-    throw new Error(text, { cause: e })
+    throw new PluginError(text, { cause: e, pluginManager: this })
   }
 }
 

package/src/managers/pluginManager/index.ts

@@ -1,3 +1,5 @@
-export * from './PluginManager'
-export * from './types'
-export * from './validate'
+export * from './PluginManager.ts'
+export * from './types.ts'
+export * from './validate.ts'
+export * from './PluginError.ts'
+export * from './ParallelPluginError.ts'

package/src/managers/pluginManager/types.ts

@@ -1,4 +1,5 @@
-import type { PluginLifecycle } from '../../types'
+import type { PluginManager } from './PluginManager.ts'
+import type { KubbPlugin, PluginLifecycle, PluginLifecycleHooks } from '../../types.ts'
 /**
  * Get the type of the first argument in a function.
  * @example Arg0<(a: string, b: number) => void> -> string
@@ -6,3 +7,11 @@ import type { PluginLifecycle } from '../../types'
 export type Argument0<H extends keyof PluginLifecycle> = Parameters<PluginLifecycle[H]>[0]
 
 export type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq'
+
+export type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  strategy: Strategy
+  hookName: H
+  plugin: KubbPlugin
+}
+
+export type OnExecute<H extends PluginLifecycleHooks = PluginLifecycleHooks> = (this: PluginManager, executer: Executer<H> | undefined) => void

package/src/managers/pluginManager/validate.ts

@@ -1,4 +1,4 @@
-import type { KubbPlugin } from '../../types'
+import type { KubbPlugin } from '../../types.ts'
 
 export class ValidationPluginError extends Error {}
 

package/src/plugin.ts

@@ -1,9 +1,10 @@
-import pathParser from 'path'
+import pathParser from 'node:path'
 
-import { createPluginCache, transformReservedWord } from './utils'
+import { createPluginCache, getStackTrace, transformReservedWord } from './utils/index.ts'
 
-import type { FileManager } from './managers/fileManager'
-import type { PluginContext, KubbPlugin, PluginFactoryOptions } from './types'
+import type { Executer } from './managers/index.ts'
+import type { FileManager } from './managers/fileManager/FileManager.ts'
+import type { PluginContext, KubbPlugin, PluginFactoryOptions, PluginLifecycleHooks } from './types.ts'
 
 type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (
   options: T['options']
@@ -33,6 +34,7 @@ type Options = {
   resolvePath: PluginContext['resolvePath']
   resolveName: PluginContext['resolveName']
   load: PluginContext['load']
+  getExecuter: () => Executer<PluginLifecycleHooks> | undefined
 }
 
 // not publicly exported
@@ -49,7 +51,34 @@ export const definePlugin = createPlugin<CorePluginOptions>((options) => {
     },
     fileManager,
     async addFile(...files) {
-      return Promise.all(files.map((file) => (file.override ? fileManager.add(file) : fileManager.addOrAppend(file))))
+      // TODO unstable, based on stack trace and name of the file(can be different)
+      const trace = getStackTrace()
+      const plugins = options.config.plugins
+        ?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name))
+        .sort((a, b) => {
+          if (a.name.length < b.name.length) return 1
+          if (a.name.length > b.name.length) return -1
+          return 0
+        })
+      const pluginName = plugins?.[0].name
+
+      return Promise.all(
+        files.map((file) => {
+          const fileWithMeta = {
+            ...file,
+            meta: {
+              ...(file.meta || {}),
+              pluginName,
+            },
+          }
+
+          if (file.override) {
+            return fileManager.add(fileWithMeta)
+          }
+
+          return fileManager.addOrAppend(fileWithMeta)
+        })
+      )
     },
     resolvePath,
     resolveName: (params) => {

package/src/types.ts

@@ -1,11 +1,20 @@
 /* eslint-disable @typescript-eslint/no-empty-interface */
-import type { FileManager, File } from './managers/fileManager'
-import type { Cache } from './utils/cache'
+import type { PluginManager } from './managers/index.ts'
+import type { FileManager, File } from './managers/fileManager/index.ts'
+import type { Cache } from './utils/cache.ts'
 
 export interface Register {}
 
 export type MaybePromise<T> = Promise<T> | T
 
+/**
+ * Config used in `kubb.config.js`
+ *
+ * @example import { defineConfig } from '@kubb/core'
+ * export default defineConfig({
+ * ...
+ * })
+ */
 export type KubbUserConfig = Omit<KubbConfig, 'root' | 'plugins'> & {
   /**
    * Project root directory. Can be an absolute path, or a path relative from
@@ -76,9 +85,27 @@ export type KubbConfig = {
 }
 
 export type CLIOptions = {
+  /**
+   * Path to `kubb.config.js`
+   */
   config?: string
+  /**
+   * Enable debug mode
+   */
   debug?: boolean
+  /**
+   * Watch changes on input
+   */
   watch?: string
+  /**
+   * Override input defined in `kubb.config.js`
+   */
+  input?: string
+}
+
+export type BuildOutput = {
+  files: FileManager['files']
+  pluginManager: PluginManager
 }
 
 // plugin
@@ -109,7 +136,7 @@ export type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOpti
    */
   api?: TOptions['api']
   /**
-   * Options set for a specific plugin(see kubb.config.ts)
+   * Options set for a specific plugin(see kubb.config.js)
    */
   options?: TOptions['options']
 } & Partial<PluginLifecycle<TOptions>>
@@ -200,7 +227,7 @@ export type PluginContext<TOptions = Record<string, any>> = {
   fileManager: FileManager
   addFile: (...file: File[]) => Promise<File[]>
   resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath
-  resolveName: (params: ResolveNameParams) => string
+  resolveName: (params: ResolveNameParams) => string | null | undefined
   load: (id: string) => MaybePromise<TransformResult | void>
 }
 

package/src/utils/clean.ts

@@ -1,13 +1,5 @@
-import rimraf from 'rimraf'
+import { rimraf } from 'rimraf'
 
 export async function clean(path: string) {
-  return new Promise((resolve, reject) => {
-    rimraf(path, (err) => {
-      if (err) {
-        reject(err)
-      } else {
-        resolve(true)
-      }
-    })
-  })
+  return rimraf(path)
 }

package/src/utils/getStackTrace.ts

@@ -0,0 +1,19 @@
+// eslint-disable-next-line @typescript-eslint/ban-types, no-undef
+export function getStackTrace(belowFn?: Function): NodeJS.CallSite[] {
+  const oldLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = Infinity
+
+  const dummyObject = {} as any
+
+  const v8Handler = Error.prepareStackTrace
+  Error.prepareStackTrace = function prepareStackTrace(dummyObject, v8StackTrace) {
+    return v8StackTrace
+  }
+  Error.captureStackTrace(dummyObject, belowFn || getStackTrace)
+
+  const v8StackTrace = dummyObject.stack
+  Error.prepareStackTrace = v8Handler
+  Error.stackTraceLimit = oldLimit
+
+  return v8StackTrace
+}

package/src/utils/index.ts

@@ -1,16 +1,17 @@
-export * from './isPromise'
-export * from './write'
-export * from './cache'
-export * from './read'
-export * from './isURL'
-export * from './objectToParameters'
-export * from './nameSorter'
-export * from './jsdoc'
-export * from './getUniqueName'
-export * from './timeout'
-export * from './Queue'
-export * from './getEncodedText'
-export * from './renderTemplate'
-export * from './clean'
-export * from './TreeNode'
-export * from './transformReservedWord'
+export * from './isPromise.ts'
+export * from './write.ts'
+export * from './cache.ts'
+export * from './read.ts'
+export * from './isURL.ts'
+export * from './objectToParameters.ts'
+export * from './nameSorter.ts'
+export * from './jsdoc.ts'
+export * from './getUniqueName.ts'
+export * from './timeout.ts'
+export * from './Queue.ts'
+export * from './getEncodedText.ts'
+export * from './renderTemplate.ts'
+export * from './clean.ts'
+export * from './TreeNode.ts'
+export * from './transformReservedWord.ts'
+export * from './getStackTrace.ts'

package/src/utils/isPromise.ts

@@ -1,4 +1,4 @@
-import type { MaybePromise } from '../types'
+import type { MaybePromise } from '../types.ts'
 
 export function isPromise<T>(result: MaybePromise<T>): result is Promise<T> {
   return typeof (result as Promise<unknown>)?.then === 'function'

package/src/utils/read.ts

@@ -1,5 +1,5 @@
-import pathParser from 'path'
-import { promises as fs } from 'fs'
+import pathParser from 'node:path'
+import { promises as fs } from 'node:fs'
 
 function slash(path: string) {
   const isExtendedLengthPath = /^\\\\\?\\/.test(path)

package/src/utils/transformReservedWord.ts

@@ -88,8 +88,8 @@ const reservedWords = [
   'valueOf',
 ]
 
-export function transformReservedWord(word: string) {
-  if (reservedWords.includes(word)) {
+export function transformReservedWord(word?: string | null) {
+  if (word && reservedWords.includes(word)) {
     return `_${word}`
   }
 

package/src/utils/write.ts

@@ -1,6 +1,6 @@
 /* eslint-disable consistent-return */
-import { promises as fs } from 'fs'
-import pathParser from 'path'
+import { promises as fs } from 'node:fs'
+import pathParser from 'node:path'
 
 async function safeWriteFileToPath(path: string, data: string) {
   // resolve the full path and get just the directory, ignoring the file and extension