@kubb/core 3.0.0-alpha.3 → 3.0.0-alpha.30

package/src/PluginManager.ts

@@ -1,11 +1,7 @@
-import PQueue from 'p-queue'
-
-import { readSync } from '@kubb/fs'
-import { FileManager, type ResolvedFile } from './FileManager.ts'
+import { FileManager } from './FileManager.ts'
 import { isPromise, isPromiseRejectedResult } from './PromiseManager.ts'
 import { PromiseManager } from './PromiseManager.ts'
 import { ValidationPluginError } from './errors.ts'
-import { LogLevel } from './logger.ts'
 import { pluginCore } from './plugin.ts'
 import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
@@ -41,6 +37,7 @@ type Argument0<H extends keyof PluginLifecycle> = Parameters<RequiredPluginLifec
 type Strategy = 'hookFirst' | 'hookForPlugin' | 'hookParallel' | 'hookReduceArg0' | 'hookSeq'
 
 type Executer<H extends PluginLifecycleHooks = PluginLifecycleHooks> = {
+  message: string
   strategy: Strategy
   hookName: H
   plugin: Plugin
@@ -59,15 +56,10 @@ type SafeParseResult<H extends PluginLifecycleHooks, Result = ReturnType<ParseRe
 
 type Options = {
   logger: Logger
-
-  /**
-   * Task for the FileManager
-   */
-  task: (file: ResolvedFile) => Promise<ResolvedFile>
 }
 
 type Events = {
-  execute: [executer: Executer]
+  executing: [executer: Executer]
   executed: [executer: Executer]
   error: [error: Error]
 }
@@ -75,13 +67,13 @@ type Events = {
 type GetFileProps<TOptions = object> = {
   name: string
   mode?: KubbFile.Mode
-  extName: KubbFile.Extname
+  extname: KubbFile.Extname
   pluginKey: Plugin['key']
   options?: TOptions
 }
 
 export class PluginManager {
-  readonly plugins: PluginWithLifeCycle[]
+  readonly plugins = new Set<Plugin<GetPluginFactoryOptions<any>>>()
   readonly fileManager: FileManager
   readonly events: EventEmitter<Events> = new EventEmitter()
 
@@ -89,27 +81,21 @@ export class PluginManager {
 
   readonly executed: Array<Executer> = []
   readonly logger: Logger
+  readonly options: Options
   readonly #core: Plugin<PluginCore>
 
   readonly #usedPluginNames: Record<string, number> = {}
   readonly #promiseManager: PromiseManager
 
-  readonly queue: PQueue
-
   constructor(config: Config, options: Options) {
     this.config = config
+    this.options = options
     this.logger = options.logger
-    this.queue = new PQueue({ concurrency: 1 })
-    this.fileManager = new FileManager({
-      task: options.task,
-      queue: this.queue,
-    })
+    this.fileManager = new FileManager()
     this.#promiseManager = new PromiseManager({
       nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result,
     })
 
-    const plugins = config.plugins || []
-
     const core = pluginCore({
       config,
       logger: this.logger,
@@ -122,36 +108,30 @@ export class PluginManager {
 
     // call core.context.call with empty context so we can transform `context()` to `context: {}`
     this.#core = this.#parse(core as unknown as UserPlugin, this as any, core.context.call(null as any)) as Plugin<PluginCore>
+    ;[this.#core, ...(config.plugins || [])].forEach((plugin) => {
+      const parsedPlugin = this.#parse(plugin as UserPlugin, this, this.#core.context)
 
-    this.plugins = [this.#core, ...plugins].map((plugin) => {
-      return this.#parse(plugin as UserPlugin, this, this.#core.context)
+      this.plugins.add(parsedPlugin)
     })
 
     return this
   }
 
-  getFile<TOptions = object>({ name, mode, extName, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
-    let source = ''
-    const baseName = `${name}${extName}` as const
+  getFile<TOptions = object>({ name, mode, extname, pluginKey, options }: GetFileProps<TOptions>): KubbFile.File<{ pluginKey: Plugin['key'] }> {
+    const baseName = `${name}${extname}` as const
     const path = this.resolvePath({ baseName, mode, pluginKey, options })
 
     if (!path) {
       throw new Error(`Filepath should be defined for resolvedName "${name}" and pluginKey [${JSON.stringify(pluginKey)}]`)
     }
 
-    try {
-      source = readSync(path)
-    } catch (_e) {
-      //
-    }
-
     return {
       path,
       baseName,
       meta: {
         pluginKey,
       },
-      source,
+      sources: [],
     }
   }
 
@@ -161,14 +141,18 @@ 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', [
-          `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`,
-        ])
+        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)
@@ -176,22 +160,28 @@ export class PluginManager {
     return this.hookFirstSync({
       hookName: 'resolvePath',
       parameters: [params.baseName, params.mode, params.options as object],
+      message: `Resolving path '${params.baseName}'`,
     }).result
   }
+  //TODO refactor by using the order of plugins and the cache of the fileManager instead of guessing and recreating the name/path
   resolveName = (params: ResolveNameParams): string => {
     if (params.pluginKey) {
       const names = this.hookForPluginSync({
         pluginKey: params.pluginKey,
         hookName: 'resolveName',
         parameters: [params.name, params.type],
+        message: `Resolving name '${params.name}' and type '${params.type}'`,
       })
 
       if (names && names?.length > 1) {
-        this.logger.emit('debug', [
-          `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`,
-        ])
+        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`,
+          ],
+        })
       }
 
       return transformReservedWord(names?.at(0) || params.name)
@@ -200,6 +190,7 @@ export class PluginManager {
     const name = this.hookFirstSync({
       hookName: 'resolveName',
       parameters: [params.name, params.type],
+      message: `Resolving name '${params.name}' and type '${params.type}'`,
     }).result
 
     return transformReservedWord(name)
@@ -215,17 +206,21 @@ export class PluginManager {
   /**
    * Run a specific hookName for plugin x.
    */
-  hookForPlugin<H extends PluginLifecycleHooks>({
+  async hookForPlugin<H extends PluginLifecycleHooks>({
     pluginKey,
     hookName,
     parameters,
+    message,
   }: {
     pluginKey: Plugin['key']
     hookName: H
     parameters: PluginParameter<H>
-  }): Promise<Array<ReturnType<ParseResult<H>> | null>> | null {
+    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...' })
+
     const promises = plugins
       .map((plugin) => {
         return this.#execute<H>({
@@ -233,11 +228,16 @@ export class PluginManager {
           hookName,
           parameters,
           plugin,
+          message,
         })
       })
       .filter(Boolean)
 
-    return Promise.all(promises)
+    const items = await Promise.all(promises)
+
+    this.logger.emit('progress_stop', { id: hookName })
+
+    return items
   }
   /**
    * Run a specific hookName for plugin x.
@@ -247,23 +247,28 @@ 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)
 
-    return plugins
+    const result = plugins
       .map((plugin) => {
         return this.#executeSync<H>({
           strategy: 'hookFirst',
           hookName,
           parameters,
           plugin,
+          message,
         })
       })
       .filter(Boolean)
+
+    return result
   }
 
   /**
@@ -273,32 +278,41 @@ export class PluginManager {
     hookName,
     parameters,
     skipped,
+    message,
   }: {
     hookName: H
     parameters: PluginParameter<H>
     skipped?: ReadonlySet<Plugin> | null
+    message: string
   }): Promise<SafeParseResult<H>> {
-    const promises = this.#getSortedPlugins()
-      .filter((plugin) => {
-        return skipped ? skipped.has(plugin) : true
-      })
-      .map((plugin) => {
-        return async () => {
-          const value = await this.#execute<H>({
-            strategy: 'hookFirst',
-            hookName,
-            parameters,
-            plugin,
-          })
+    const plugins = this.#getSortedPlugins(hookName).filter((plugin) => {
+      return skipped ? skipped.has(plugin) : true
+    })
 
-          return Promise.resolve({
-            plugin,
-            result: value,
-          } as SafeParseResult<H>)
-        }
-      })
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+
+    const promises = plugins.map((plugin) => {
+      return async () => {
+        const value = await this.#execute<H>({
+          strategy: 'hookFirst',
+          hookName,
+          parameters,
+          plugin,
+          message,
+        })
 
-    return this.#promiseManager.run('first', promises)
+        return Promise.resolve({
+          plugin,
+          result: value,
+        } as SafeParseResult<H>)
+      }
+    })
+
+    const result = await this.#promiseManager.run('first', promises)
+
+    this.logger.emit('progress_stop', { id: hookName })
+
+    return result
   }
 
   /**
@@ -308,24 +322,26 @@ 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) => {
+      return skipped ? skipped.has(plugin) : true
+    })
 
-    for (const plugin of this.#getSortedPlugins()) {
-      if (skipped?.has(plugin)) {
-        continue
-      }
-
+    for (const plugin of plugins) {
       parseResult = {
         result: this.#executeSync<H>({
           strategy: 'hookFirst',
           hookName,
           parameters,
           plugin,
+          message,
         }),
         plugin,
       } as SafeParseResult<H>
@@ -334,6 +350,7 @@ export class PluginManager {
         break
       }
     }
+
     return parseResult
   }
 
@@ -343,17 +360,23 @@ 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 promises = this.#getSortedPlugins().map((plugin) => {
+    const plugins = this.#getSortedPlugins(hookName)
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+
+    const promises = plugins.map((plugin) => {
       return () =>
         this.#execute({
           strategy: 'hookParallel',
           hookName,
           parameters,
           plugin,
+          message,
         }) as Promise<TOuput>
     })
 
@@ -361,12 +384,14 @@ export class PluginManager {
 
     results.forEach((result, index) => {
       if (isPromiseRejectedResult<Error>(result)) {
-        const plugin = this.#getSortedPlugins()[index]
+        const plugin = this.#getSortedPlugins(hookName)[index]
 
         this.#catcher<H>(result.reason, plugin, hookName)
       }
     })
 
+    this.logger.emit('progress_stop', { id: hookName })
+
     return results.filter((result) => result.status === 'fulfilled').map((result) => (result as PromiseFulfilledResult<Awaited<TOuput>>).value)
   }
 
@@ -377,15 +402,18 @@ export class PluginManager {
     hookName,
     parameters,
     reduce,
+    message,
   }: {
     hookName: H
     parameters: PluginParameter<H>
     reduce: (reduction: Argument0<H>, result: ReturnType<ParseResult<H>>, plugin: Plugin) => PossiblePromise<Argument0<H> | null>
+    message: string
   }): Promise<Argument0<H>> {
     const [argument0, ...rest] = parameters
+    const plugins = this.#getSortedPlugins(hookName)
 
     let promise: Promise<Argument0<H>> = Promise.resolve(argument0)
-    for (const plugin of this.#getSortedPlugins()) {
+    for (const plugin of plugins) {
       promise = promise
         .then((arg0) => {
           const value = this.#execute({
@@ -393,6 +421,7 @@ export class PluginManager {
             hookName,
             parameters: [arg0, ...rest] as PluginParameter<H>,
             plugin,
+            message,
           })
           return value
         })
@@ -405,32 +434,35 @@ export class PluginManager {
   /**
    * Chains plugins
    */
-  async hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: { hookName: H; parameters?: PluginParameter<H> }): Promise<void> {
-    const promises = this.#getSortedPlugins().map((plugin) => {
+  async hookSeq<H extends PluginLifecycleHooks>({
+    hookName,
+    parameters,
+    message,
+  }: { hookName: H; parameters?: PluginParameter<H>; message: string }): Promise<void> {
+    const plugins = this.#getSortedPlugins(hookName)
+    this.logger.emit('progress_start', { id: hookName, size: plugins.length })
+
+    const promises = plugins.map((plugin) => {
       return () =>
         this.#execute({
           strategy: 'hookSeq',
           hookName,
           parameters,
           plugin,
+          message,
         })
     })
 
-    return this.#promiseManager.run('seq', promises)
+    await this.#promiseManager.run('seq', promises)
+
+    this.logger.emit('progress_stop', { id: hookName })
   }
 
   #getSortedPlugins(hookName?: keyof PluginLifecycle): Plugin[] {
     const plugins = [...this.plugins].filter((plugin) => plugin.name !== 'core')
 
     if (hookName) {
-      if (this.logger.logLevel === LogLevel.info) {
-        const containsHookName = plugins.some((item) => item[hookName])
-        if (!containsHookName) {
-          this.logger.emit('warning', `No hook ${hookName} found`)
-        }
-      }
-
-      return plugins.filter((item) => item[hookName])
+      return plugins.filter((plugin) => hookName in plugin)
     }
     // TODO add test case for sorting with pre/post
 
@@ -462,7 +494,7 @@ export class PluginManager {
     const [searchPluginName, searchIdentifier] = pluginKey
 
     const pluginByPluginName = plugins
-      .filter((plugin) => plugin[hookName])
+      .filter((plugin) => hookName in plugin)
       .filter((item) => {
         const [name, identifier] = item.key
 
@@ -479,12 +511,18 @@ export class PluginManager {
     if (!pluginByPluginName?.length) {
       // fallback on the core plugin when there is no match
 
-      const corePlugin = plugins.find((plugin) => plugin.name === 'core' && plugin[hookName])
+      const corePlugin = plugins.find((plugin) => plugin.name === 'core' && hookName in plugin)
 
       if (corePlugin) {
-        this.logger.emit('debug', [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`])
+        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', [`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`])
+        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] : []
     }
@@ -496,6 +534,8 @@ export class PluginManager {
     if (executer) {
       this.events.emit('executed', executer)
       this.executed.push(executer)
+
+      this.logger.emit('progressed', { id: executer.hookName, message: `${executer.plugin.name}: ${executer.message}` })
     }
   }
 
@@ -511,11 +551,13 @@ 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
@@ -524,9 +566,12 @@ export class PluginManager {
       return null
     }
 
-    this.events.emit('execute', { strategy, hookName, parameters, plugin })
+    this.events.emit('executing', { strategy, hookName, parameters, plugin, message })
+    const promise = new Promise((resolve) => {
+      resolve(undefined)
+    })
 
-    const task = Promise.resolve()
+    const task = promise
       .then(() => {
         if (typeof hook === 'function') {
           const possiblePromiseResult = (hook as Function).apply({ ...this.#core.context, plugin }, parameters) as Promise<ReturnType<ParseResult<H>>>
@@ -548,6 +593,7 @@ export class PluginManager {
           strategy,
           hookName,
           plugin,
+          message,
         })
 
         return result
@@ -573,11 +619,13 @@ 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
@@ -586,13 +634,23 @@ export class PluginManager {
       return null
     }
 
-    this.events.emit('execute', { strategy, hookName, parameters, plugin })
+    this.events.emit('executing', { strategy, hookName, parameters, plugin, message })
 
     try {
       if (typeof hook === 'function') {
         const fn = (hook as Function).apply({ ...this.#core.context, plugin }, parameters) as ReturnType<ParseResult<H>>
 
         output = fn
+
+        this.#addExecutedToCallStack({
+          parameters,
+          output,
+          strategy,
+          hookName,
+          plugin,
+          message,
+        })
+
         return fn
       }
 
@@ -604,6 +662,7 @@ export class PluginManager {
         strategy,
         hookName,
         plugin,
+        message,
       })
 
       return hook

package/src/PromiseManager.ts

@@ -42,7 +42,7 @@ export function isPromise<T>(result: PossiblePromise<T>): result is Promise<T> {
   return !!result && typeof (result as Promise<unknown>)?.then === 'function'
 }
 
-export function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {
+function isPromiseFulfilledResult<T = unknown>(result: PromiseSettledResult<unknown>): result is PromiseFulfilledResult<T> {
   return result.status === 'fulfilled'
 }
 

package/src/__snapshots__/barrel.json

@@ -0,0 +1,73 @@
+[
+  {
+    "path": "src/index.ts",
+    "baseName": "index.ts",
+    "exports": [
+      {
+        "path": "./sub/hello.ts"
+      },
+      {
+        "path": "./sub/world.ts"
+      },
+      {
+        "path": "./test.ts"
+      }
+    ],
+    "sources": [
+      {
+        "name": "test",
+        "value": "",
+        "isExportable": false,
+        "isIndexable": false
+      },
+      {
+        "name": "hello",
+        "value": "",
+        "isExportable": false,
+        "isIndexable": false
+      },
+      {
+        "name": "world",
+        "value": "",
+        "isExportable": false,
+        "isIndexable": false
+      }
+    ],
+    "id": "feabc02536bd6630458e734990f7e2a21a55c469",
+    "name": "index",
+    "extname": ".ts",
+    "imports": [],
+    "meta": {}
+  },
+  {
+    "path": "src/sub/index.ts",
+    "baseName": "index.ts",
+    "exports": [
+      {
+        "path": "./hello.ts"
+      },
+      {
+        "path": "./world.ts"
+      }
+    ],
+    "sources": [
+      {
+        "name": "hello",
+        "value": "",
+        "isExportable": false,
+        "isIndexable": false
+      },
+      {
+        "name": "world",
+        "value": "",
+        "isExportable": false,
+        "isIndexable": false
+      }
+    ],
+    "id": "c67967bd2363dd9637437671f6fe1ed146debdbf",
+    "name": "index",
+    "extname": ".ts",
+    "imports": [],
+    "meta": {}
+  }
+]