@kubb/core 4.11.1 → 4.11.2

package/src/PluginManager.ts

@@ -1,4 +1,5 @@
 import path from 'node:path'
+import { performance } from 'node:perf_hooks'
 import type { KubbFile } from '@kubb/fabric-core/types'
 import type { Fabric } from '@kubb/react-fabric'
 import { ValidationPluginError } from './errors.ts'
@@ -27,8 +28,7 @@ type RequiredPluginLifecycle = Required<PluginLifecycle>
 
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookSeq'
 
-type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
-  message: string
+type ExecutingMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   strategy: Strategy
   hookName: H
   plugin: Plugin
@@ -36,6 +36,32 @@ type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
   output?: unknown
 }
 
+type ExecutedMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  duration: number
+  strategy: Strategy
+  hookName: H
+  plugin: Plugin
+  parameters?: unknown[] | undefined
+  output?: unknown
+}
+
+type ErrorMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H
+  duration: number
+  strategy: Strategy
+  parameters?: unknown[] | undefined
+  plugin: Plugin
+}
+
+type ProgressStartMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H
+  plugins: Array<Plugin>
+}
+
+type ProgressStopMeta<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  hookName: H
+}
+
 type ParseResult<H extends PluginLifecycleHooks> = RequiredPluginLifecycle[H]
 
 type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseResult<H>>> = {
@@ -55,9 +81,11 @@ type Options = {
 }
 
 type Events = {
-  executing: [executer: Executer]
-  executed: [executer: Executer]
-  error: [error: Error]
+  progress_start: [meta: ProgressStartMeta]
+  progress_stop: [meta: ProgressStopMeta]
+  executing: [meta: ExecutingMeta]
+  executed: [meta: ExecutedMeta]
+  error: [error: Error, meta: ErrorMeta]
 }
 
 type GetFileProps<TOptions = object> = {
@@ -79,9 +107,6 @@ export class PluginManager {
   readonly events: EventEmitter<Events> = new EventEmitter()
 
   readonly config: Config
-
-  readonly executed: Array<Executer> = []
-  readonly logger: Logger
   readonly options: Options
 
   readonly #plugins = new Set<Plugin<GetPluginFactoryOptions<any>>>()
@@ -91,11 +116,9 @@ export class PluginManager {
   constructor(config: Config, options: Options) {
     this.config = config
     this.options = options
-    this.logger = options.logger
     this.#promiseManager = new PromiseManager({
       nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result,
     })
-
     ;[...(config.plugins || [])].forEach((plugin) => {
       const parsedPlugin = this.#parse(plugin as UserPlugin)
 
@@ -171,27 +194,14 @@ export class PluginManager {
         pluginKey: params.pluginKey,
         hookName: 'resolvePath',
         parameters: [params.baseName, params.mode, params.options as object],
-        message: `Resolving path '${params.baseName}'`,
       })
 
-      if (paths && paths?.length > 1) {
-        this.logger.emit('debug', {
-          date: new Date(),
-          logs: [
-            `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`,
-          ],
-        })
-      }
-
       return paths?.at(0) || defaultPath
     }
 
     const firstResult = this.hookFirstSync({
       hookName: 'resolvePath',
       parameters: [params.baseName, params.mode, params.options as object],
-      message: `Resolving path '${params.baseName}'`,
     })
 
     return firstResult?.result || defaultPath
@@ -203,27 +213,16 @@ export class PluginManager {
         pluginKey: params.pluginKey,
         hookName: 'resolveName',
         parameters: [trim(params.name), params.type],
-        message: `Resolving name '${params.name}' and type '${params.type}'`,
       })
 
-      if (names && names?.length > 1) {
-        this.logger.emit('debug', {
-          date: new Date(),
-          logs: [
-            `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`,
-          ],
-        })
-      }
+      const uniqueNames = new Set(names)
 
-      return transformReservedWord(names?.at(0) || params.name)
+      return transformReservedWord([...uniqueNames].at(0) || params.name)
     }
 
     const name = this.hookFirstSync({
       hookName: 'resolveName',
       parameters: [trim(params.name), params.type],
-      message: `Resolving name '${params.name}' and type '${params.type}'`,
     }).result
 
     return transformReservedWord(name)
@@ -243,16 +242,17 @@ export class PluginManager {
     pluginKey,
     hookName,
     parameters,
-    message,
   }: {
     pluginKey: Plugin['key']
     hookName: H
     parameters: PluginParameter<H>
-    message: string
   }): Promise<Array<ReturnType<ParseResult<H>> | null>> {
     const plugins = this.getPluginsByKey(hookName, pluginKey)
 
-    this.logger.emit('progress_start', { id: hookName, size: plugins.length, message: 'Running plugins...' })
+    this.events.emit('progress_start', {
+      hookName,
+      plugins,
+    })
 
     const items: Array<ReturnType<ParseResult<H>>> = []
 
@@ -262,7 +262,6 @@ export class PluginManager {
         hookName,
         parameters,
         plugin,
-        message,
       })
 
       if (result !== undefined && result !== null) {
@@ -270,7 +269,7 @@ export class PluginManager {
       }
     }
 
-    this.logger.emit('progress_stop', { id: hookName })
+    this.events.emit('progress_stop', { hookName })
 
     return items
   }
@@ -282,12 +281,10 @@ export class PluginManager {
     pluginKey,
     hookName,
     parameters,
-    message,
   }: {
     pluginKey: Plugin['key']
     hookName: H
     parameters: PluginParameter<H>
-    message: string
   }): Array<ReturnType<ParseResult<H>>> | null {
     const plugins = this.getPluginsByKey(hookName, pluginKey)
 
@@ -298,7 +295,6 @@ export class PluginManager {
           hookName,
           parameters,
           plugin,
-          message,
         })
       })
       .filter(Boolean)
@@ -313,18 +309,16 @@ export class PluginManager {
     hookName,
     parameters,
     skipped,
-    message,
   }: {
     hookName: H
     parameters: PluginParameter<H>
     skipped?: ReadonlySet<Plugin> | null
-    message: string
   }): Promise<SafeParseResult<H>> {
     const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
       return skipped ? skipped.has(plugin) : true
     })
 
-    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+    this.events.emit('progress_start', { hookName, plugins })
 
     const promises = plugins.map((plugin) => {
       return async () => {
@@ -333,7 +327,6 @@ export class PluginManager {
           hookName,
           parameters,
           plugin,
-          message,
         })
 
         return Promise.resolve({
@@ -345,7 +338,7 @@ export class PluginManager {
 
     const result = await this.#promiseManager.run('first', promises)
 
-    this.logger.emit('progress_stop', { id: hookName })
+    this.events.emit('progress_stop', { hookName })
 
     return result
   }
@@ -357,12 +350,10 @@ export class PluginManager {
     hookName,
     parameters,
     skipped,
-    message,
   }: {
     hookName: H
     parameters: PluginParameter<H>
     skipped?: ReadonlySet<Plugin> | null
-    message: string
   }): SafeParseResult<H> {
     let parseResult: SafeParseResult<H> = null as unknown as SafeParseResult<H>
     const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
@@ -376,7 +367,6 @@ export class PluginManager {
           hookName,
           parameters,
           plugin,
-          message,
         }),
         plugin,
       } as SafeParseResult<H>
@@ -395,14 +385,12 @@ export class PluginManager {
   async hookParallel<H extends PluginLifecycleHooks, TOuput = void>({
     hookName,
     parameters,
-    message,
   }: {
     hookName: H
     parameters?: Parameters<RequiredPluginLifecycle[H]> | undefined
-    message: string
   }): Promise<Awaited<TOuput>[]> {
     const plugins = this.#getSortedPlugins(hookName)
-    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+    this.events.emit('progress_start', { hookName, plugins })
 
     const promises = plugins.map((plugin) => {
       return () =>
@@ -411,21 +399,24 @@ export class PluginManager {
           hookName,
           parameters,
           plugin,
-          message,
         }) as Promise<TOuput>
     })
 
-    const results = await this.#promiseManager.run('parallel', promises, { concurrency: this.options.concurrency })
+    const results = await this.#promiseManager.run('parallel', promises, {
+      concurrency: this.options.concurrency,
+    })
 
     results.forEach((result, index) => {
       if (isPromiseRejectedResult<Error>(result)) {
         const plugin = this.#getSortedPlugins(hookName)[index]
 
-        this.#catcher<H>(result.reason, plugin, hookName)
+        if (plugin) {
+          this.events.emit('error', result.reason, { plugin, hookName, strategy: 'hookParallel', duration: 0, parameters })
+        }
       }
     })
 
-    this.logger.emit('progress_stop', { id: hookName })
+    this.events.emit('progress_stop', { hookName })
 
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
@@ -433,17 +424,9 @@ export class PluginManager {
   /**
    * Chains plugins
    */
-  async hookSeq<H extends PluginLifecycleHooks>({
-    hookName,
-    parameters,
-    message,
-  }: {
-    hookName: H
-    parameters?: PluginParameter<H>
-    message: string
-  }): Promise<void> {
+  async hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: PluginParameter<H> }): Promise<void> {
     const plugins = this.#getSortedPlugins(hookName)
-    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+    this.events.emit('progress_start', { hookName, plugins })
 
     const promises = plugins.map((plugin) => {
       return () =>
@@ -452,13 +435,12 @@ export class PluginManager {
           hookName,
           parameters,
           plugin,
-          message,
         })
     })
 
     await this.#promiseManager.run('seq', promises)
 
-    this.logger.emit('progress_stop', { id: hookName })
+    this.events.emit('progress_stop', { hookName })
   }
 
   #getSortedPlugins(hookName?: keyof PluginLifecycle): Array<Plugin> {
@@ -526,33 +508,14 @@ export class PluginManager {
       // fallback on the core plugin when there is no match
 
       const corePlugin = plugins.find((plugin) => plugin.name === 'core' && hookName in plugin)
+      // Removed noisy debug logs for missing hooks - these are expected behavior, not errors
 
-      if (corePlugin) {
-        this.logger.emit('debug', {
-          date: new Date(),
-          logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`],
-        })
-      } else {
-        this.logger.emit('debug', {
-          date: new Date(),
-          logs: [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`],
-        })
-      }
       return corePlugin ? [corePlugin] : []
     }
 
     return pluginByPluginName
   }
 
-  #addExecutedToCallStack(executer: Executer | undefined) {
-    if (executer) {
-      this.events.emit('executed', executer)
-      this.executed.push(executer)
-
-      this.logger.emit('progressed', { id: executer.hookName, message: `${executer.plugin.name}: ${executer.message}` })
-    }
-  }
-
   /**
    * Run an async plugin hook and return the result.
    * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
@@ -565,13 +528,11 @@ export class PluginManager {
     hookName,
     parameters,
     plugin,
-    message,
   }: {
     strategy: Strategy
     hookName: H
     parameters: unknown[] | undefined
     plugin: PluginWithLifeCycle
-    message: string
   }): Promise<ReturnType<ParseResult<H>> | null> | null {
     const hook = plugin[hookName]
     let output: unknown
@@ -580,7 +541,14 @@ export class PluginManager {
       return null
     }
 
-    this.events.emit('executing', { strategy, hookName, parameters, plugin, message })
+    this.events.emit('executing', {
+      strategy,
+      hookName,
+      parameters,
+      plugin,
+    })
+
+    const startTime = performance.now()
 
     const task = (async () => {
       try {
@@ -590,13 +558,13 @@ export class PluginManager {
 
           output = result
 
-          this.#addExecutedToCallStack({
+          this.events.emit('executed', {
+            duration: Math.round(performance.now() - startTime),
             parameters,
             output,
             strategy,
             hookName,
             plugin,
-            message,
           })
 
           return result
@@ -604,18 +572,19 @@ export class PluginManager {
 
         output = hook
 
-        this.#addExecutedToCallStack({
+        this.events.emit('executed', {
+          duration: Math.round(performance.now() - startTime),
           parameters,
           output,
           strategy,
           hookName,
           plugin,
-          message,
         })
 
         return hook
       } catch (e) {
-        this.#catcher<H>(e as Error, plugin, hookName)
+        this.events.emit('error', e as Error, { plugin, hookName, strategy, duration: Math.round(performance.now() - startTime) })
+
         return null
       }
     })()
@@ -635,13 +604,11 @@ export class PluginManager {
     hookName,
     parameters,
     plugin,
-    message,
   }: {
     strategy: Strategy
     hookName: H
     parameters: PluginParameter<H>
     plugin: PluginWithLifeCycle
-    message: string
   }): ReturnType<ParseResult<H>> | null {
     const hook = plugin[hookName]
     let output: unknown
@@ -650,7 +617,14 @@ export class PluginManager {
       return null
     }
 
-    this.events.emit('executing', { strategy, hookName, parameters, plugin, message })
+    this.events.emit('executing', {
+      strategy,
+      hookName,
+      parameters,
+      plugin,
+    })
+
+    const startTime = performance.now()
 
     try {
       if (typeof hook === 'function') {
@@ -659,13 +633,13 @@ export class PluginManager {
 
         output = fn
 
-        this.#addExecutedToCallStack({
+        this.events.emit('executed', {
+          duration: Math.round(performance.now() - startTime),
           parameters,
           output,
           strategy,
           hookName,
           plugin,
-          message,
         })
 
         return fn
@@ -673,30 +647,23 @@ export class PluginManager {
 
       output = hook
 
-      this.#addExecutedToCallStack({
+      this.events.emit('executed', {
+        duration: Math.round(performance.now() - startTime),
         parameters,
         output,
         strategy,
         hookName,
         plugin,
-        message,
       })
 
       return hook
     } catch (e) {
-      this.#catcher<H>(e as Error, plugin, hookName)
+      this.events.emit('error', e as Error, { plugin, hookName, strategy, duration: Math.round(performance.now() - startTime) })
 
       return null
     }
   }
 
-  #catcher<H extends PluginLifecycleHooks>(cause: Error, plugin?: Plugin, hookName?: H) {
-    const text = `${cause.message} (plugin: ${plugin?.name || 'unknown'}, hook: ${hookName || 'unknown'})`
-
-    this.logger.emit('error', text, cause)
-    this.events.emit('error', cause)
-  }
-
   #parse(plugin: UserPlugin): Plugin {
     const usedPluginNames = this.#usedPluginNames