@kubb/core 2.0.0-beta.13 → 2.0.0-beta.14

package/src/PluginManager.ts

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/ban-types, @typescript-eslint/no-unsafe-argument */
 
+import PQueue from 'p-queue'
+
 import { transformReservedWord } from './transformers/transformReservedWord.ts'
 import { EventEmitter } from './utils/EventEmitter.ts'
-import { Queue } from './utils/Queue.ts'
 import { setUniqueName } from './utils/uniqueName.ts'
 import { ValidationPluginError } from './errors.ts'
 import { FileManager } from './FileManager.ts'
@@ -29,7 +30,6 @@ import type {
   ResolveNameParams,
   ResolvePathParams,
 } from './types.ts'
-import type { QueueJob } from './utils/Queue.ts'
 
 type RequiredPluginLifecycle = Required<PluginLifecycle>
 
@@ -64,11 +64,7 @@ type Options = {
   /**
    * Task for the FileManager
    */
-  task: QueueJob<KubbFile.ResolvedFile>
-  /**
-   * Timeout between writes in the FileManager
-   */
-  writeTimeout?: number
+  task: (file: KubbFile.ResolvedFile) => Promise<KubbFile.ResolvedFile>
 }
 
 type Events = {
@@ -82,7 +78,6 @@ export class PluginManager {
   readonly fileManager: FileManager
   readonly events: EventEmitter<Events> = new EventEmitter()
 
-  readonly queue: Queue
   readonly config: KubbConfig
 
   readonly executed: Array<Executer> = []
@@ -92,11 +87,13 @@ export class PluginManager {
   readonly #usedPluginNames: Record<string, number> = {}
   readonly #promiseManager: PromiseManager
 
+  readonly queue: PQueue
+
   constructor(config: KubbConfig, options: Options) {
     this.config = config
     this.logger = options.logger
-    this.queue = new Queue(100, this.logger.logLevel === LogLevel.debug)
-    this.fileManager = new FileManager({ task: options.task, queue: this.queue, timeout: options.writeTimeout })
+    this.queue = new PQueue({ concurrency: 1 })
+    this.fileManager = new FileManager({ task: options.task, queue: this.queue })
     this.#promiseManager = new PromiseManager({ nullCheck: (state: SafeParseResult<'resolveName'> | null) => !!state?.result })
 
     const plugins = config.plugins || []
@@ -130,7 +127,7 @@ export class PluginManager {
       })
 
       if (paths && paths?.length > 1 && this.logger.logLevel === LogLevel.debug) {
-        this.logger.warn(
+        this.logger.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`,
@@ -153,7 +150,7 @@ export class PluginManager {
       })
 
       if (names && names?.length > 1 && this.logger.logLevel === LogLevel.debug) {
-        this.logger.warn(
+        this.logger.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`,
@@ -442,9 +439,9 @@ export class PluginManager {
 
       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`)
+          this.logger.debug(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, falling back on the '@kubb/core' plugin`)
         } else {
-          this.logger.warn(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`)
+          this.logger.debug(`No hook '${hookName}' for pluginKey '${JSON.stringify(pluginKey)}' found, no fallback found in the '@kubb/core' plugin`)
         }
       }
 
@@ -594,10 +591,6 @@ export class PluginManager {
 
     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')
-    }
-
     // default transform
     if (!plugin.transform) {
       plugin.transform = function transform(code) {

package/src/build.ts

@@ -12,7 +12,6 @@ import { isPromise } from './PromiseManager.ts'
 import type { KubbFile } from './FileManager.ts'
 import type { Logger } from './logger.ts'
 import type { KubbPlugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
-import type { QueueJob } from './utils/Queue.ts'
 
 type BuildOptions = {
   config: PluginContext['config']
@@ -42,6 +41,7 @@ async function transformReducer(
 
 async function setup(options: BuildOptions): Promise<PluginManager> {
   const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options
+  let count = 0
 
   try {
     if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
@@ -62,48 +62,53 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     await clean(config.output.path)
   }
 
-  const queueTask = async (file: KubbFile.File) => {
+  const task = async (file: KubbFile.ResolvedFile): Promise<KubbFile.ResolvedFile> => {
     const { path } = file
 
-    let code: string | null = FileManager.getSource(file)
+    let source: string | null = FileManager.getSource(file)
 
     const { result: loadedResult } = await pluginManager.hookFirst({
       hookName: 'load',
       parameters: [path],
     })
     if (loadedResult && isPromise(loadedResult)) {
-      code = await loadedResult
+      source = await loadedResult
     }
     if (loadedResult && !isPromise(loadedResult)) {
-      code = loadedResult
+      source = loadedResult
     }
 
-    if (code) {
-      const transformedCode = await pluginManager.hookReduceArg0({
+    if (source) {
+      source = await pluginManager.hookReduceArg0({
         hookName: 'transform',
-        parameters: [code, path],
+        parameters: [source, path],
         reduce: transformReducer,
       })
 
       if (config.output.write || config.output.write === undefined) {
         if (file.meta?.pluginKey) {
           // run only for pluginKey defined in the meta of the file
-          return pluginManager.hookForPlugin({
+          await pluginManager.hookForPlugin({
             pluginKey: file.meta?.pluginKey,
             hookName: 'writeFile',
-            parameters: [transformedCode, path],
+            parameters: [source, path],
           })
         }
 
-        return pluginManager.hookFirst({
+        await pluginManager.hookFirst({
           hookName: 'writeFile',
-          parameters: [transformedCode, path],
+          parameters: [source, path],
         })
       }
     }
+
+    return {
+      ...file,
+      source: source || '',
+    }
   }
 
-  const pluginManager = new PluginManager(config, { logger, task: queueTask as QueueJob<KubbFile.ResolvedFile>, writeTimeout: 0 })
+  const pluginManager = new PluginManager(config, { logger, task })
 
   pluginManager.on('execute', (executer) => {
     const { hookName, parameters, plugin } = executer
@@ -111,40 +116,60 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     if (hookName === 'writeFile' && logger.spinner) {
       const [code] = parameters as PluginParameter<'writeFile'>
 
-      if (logger.logLevel === LogLevel.info) {
-        logger.spinner.start(`💾 Writing`)
-      }
-
       if (logger.logLevel === LogLevel.debug) {
-        logger.info(`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
+        logger.debug(`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
       }
     }
   })
 
-  pluginManager.on('executed', (executer) => {
-    const { hookName, plugin, output, parameters } = executer
-    const messsage = `${randomCliColour(plugin.name)} Executing ${hookName}`
+  pluginManager.queue.on('add', () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return
+    }
 
-    if (logger.logLevel === LogLevel.info && logger.spinner) {
-      if (hookName === 'writeFile') {
-        const [_code, path] = parameters as PluginParameter<'writeFile'>
+    if (logger.spinner && count === 0) {
+      logger.spinner?.start(`💾 Writing`)
+    }
+  })
 
-        logger.spinner.suffixText = c.dim(path)
-      } else {
-        logger.spinner.suffixText = messsage
-      }
+  pluginManager.queue.on('active', () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return
     }
 
+    if (logger.spinner && pluginManager.queue.size > 0) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
+
+      logger.spinner.suffixText = c.dim(text)
+    }
+    ;++count
+  })
+
+  pluginManager.queue.on('completed', () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return
+    }
+
+    if (logger.spinner) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
+
+      logger.spinner.suffixText = c.dim(text)
+    }
+  })
+
+  pluginManager.on('executed', (executer) => {
+    const { hookName, plugin, output, parameters } = executer
+
     if (logger.logLevel === LogLevel.debug) {
-      logger.info(messsage)
       const logs = [
+        `${randomCliColour(plugin.name)} Executing ${hookName}`,
         parameters && `${c.bgWhite(`Parameters`)} ${randomCliColour(plugin.name)} ${hookName}`,
         JSON.stringify(parameters, undefined, 2),
         output && `${c.bgWhite('Output')} ${randomCliColour(plugin.name)} ${hookName}`,
         output,
       ].filter(Boolean)
 
-      console.log(logs.join('\n'))
+      logger.debug(logs.join('\n'))
     }
   })
 
@@ -163,7 +188,7 @@ export async function build(options: BuildOptions): Promise<BuildOutput> {
 
   await pluginManager.hookParallel({ hookName: 'buildEnd' })
 
-  if (!fileManager.isExecuting && logger.spinner) {
+  if (logger.logLevel === LogLevel.info && logger.spinner) {
     logger.spinner.suffixText = ''
     logger.spinner.succeed(`💾 Writing completed`)
   }
@@ -184,7 +209,7 @@ export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
 
     await pluginManager.hookParallel({ hookName: 'buildEnd' })
 
-    if (!fileManager.isExecuting && logger.spinner) {
+    if (logger.logLevel === LogLevel.info && logger.spinner) {
       logger.spinner.suffixText = ''
       logger.spinner.succeed(`💾 Writing completed`)
     }

package/src/fs/clean.ts

@@ -1,5 +1,5 @@
-import { remove } from 'fs-extra'
+import fs from 'fs-extra'
 
 export async function clean(path: string): Promise<void> {
-  return remove(path)
+  return fs.remove(path)
 }

package/src/fs/read.ts

@@ -1,6 +1,7 @@
 import { basename, extname, relative } from 'node:path'
 
 import fs from 'fs-extra'
+
 import { switcher } from 'js-runtime'
 
 function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {

package/src/fs/write.ts

@@ -1,20 +1,14 @@
-import { dirname, resolve } from 'node:path'
+import { resolve } from 'node:path'
 
 import fs from 'fs-extra'
 import { switcher } from 'js-runtime'
 
-async function saveCreateDirectory(path: string): Promise<void> {
-  // resolve the full path and get just the directory, ignoring the file and extension
-  const passedPath = dirname(resolve(path))
-  // make the directory, recursively. Theoretically, if every directory in the path exists, this won't do anything.
-  await fs.mkdir(passedPath, { recursive: true })
-}
+type Options = { sanity?: boolean }
 
 const writer = switcher(
   {
-    node: async (path: string, data: string) => {
+    node: async (path: string, data: string, { sanity }: Options) => {
       try {
-        await fs.stat(resolve(path))
         const oldContent = await fs.readFile(resolve(path), { encoding: 'utf-8' })
         if (oldContent?.toString() === data?.toString()) {
           return
@@ -23,30 +17,36 @@ const writer = switcher(
         /* empty */
       }
 
-      await saveCreateDirectory(path)
-      await fs.writeFile(resolve(path), data, { encoding: 'utf-8' })
+      await fs.outputFile(resolve(path), data, { encoding: 'utf-8' })
+
+      if (sanity) {
+        const savedData = await fs.readFile(resolve(path), { encoding: 'utf-8' })
 
-      const savedData = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+        }
 
-      if (savedData?.toString() !== data?.toString()) {
-        throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+        return savedData
       }
 
-      return savedData
+      return data
     },
-    bun: async (path: string, data: string) => {
+    bun: async (path: string, data: string, { sanity }: Options) => {
       try {
-        await saveCreateDirectory(path)
         await Bun.write(resolve(path), data)
 
-        const file = Bun.file(resolve(path))
-        const savedData = await file.text()
+        if (sanity) {
+          const file = Bun.file(resolve(path))
+          const savedData = await file.text()
 
-        if (savedData?.toString() !== data?.toString()) {
-          throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+          if (savedData?.toString() !== data?.toString()) {
+            throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+          }
+
+          return savedData
         }
 
-        return savedData
+        return data
       } catch (e) {
         console.log(e, resolve(path))
       }
@@ -55,9 +55,25 @@ const writer = switcher(
   'node',
 )
 
-export async function write(data: string, path: string): Promise<string | undefined> {
+export async function write(data: string, path: string, options: Options = {}): Promise<string | undefined> {
   if (data.trim() === '') {
     return undefined
   }
-  return writer(path, data.trim())
+  return writer(path, data.trim(), options)
+}
+
+export async function writeLog(data: string): Promise<string | undefined> {
+  if (data.trim() === '') {
+    return undefined
+  }
+  const path = resolve(process.cwd(), 'kubb-log.log')
+  let previousLogs = ''
+
+  try {
+    previousLogs = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+  } catch (_err) {
+    /* empty */
+  }
+
+  return writer(path, [previousLogs, data.trim()].filter(Boolean).join('\n\n\n'), { sanity: false })
 }

package/src/logger.ts

@@ -1,6 +1,8 @@
 import seedrandom from 'seedrandom'
 import c, { createColors } from 'tinyrainbow'
 
+import { writeLog } from './fs/write.ts'
+
 import type { Ora } from 'ora'
 import type { Formatter } from 'tinyrainbow'
 
@@ -22,6 +24,7 @@ export type Logger = {
   error: (message: string | null) => void
   info: (message: string | null) => void
   warn: (message: string | null) => void
+  debug: (message: string | null) => Promise<void>
   spinner?: Ora
   logs: string[]
 }
@@ -61,6 +64,12 @@ export function createLogger({ logLevel, name, spinner }: Props): Logger {
     }
   }
 
+  const debug: Logger['debug'] = async (message) => {
+    if (message) {
+      await writeLog(message)
+    }
+  }
+
   const logger: Logger = {
     name,
     logLevel,
@@ -68,6 +77,7 @@ export function createLogger({ logLevel, name, spinner }: Props): Logger {
     error,
     warn,
     info,
+    debug,
     spinner,
     logs,
   }

package/src/utils/index.ts

@@ -1,8 +1,6 @@
 export type { FunctionParamsAST } from './FunctionParams.ts'
 export { FunctionParams } from './FunctionParams.ts'
 export { isPromise, isPromiseFulfilledResult, isPromiseRejectedResult } from './promise.ts'
-export type { QueueJob } from './Queue.ts'
-export { Queue } from './Queue.ts'
 export { renderTemplate } from './renderTemplate.ts'
 export { timeout } from './timeout.ts'
 export { getUniqueName, setUniqueName } from './uniqueName.ts'

package/dist/Queue-2-6pMcCx.d.cts

@@ -1,32 +0,0 @@
-declare class EventEmitter<TEvents extends Record<string, any>> {
-    #private;
-    constructor();
-    emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
-    on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-    off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-    removeAll(): void;
-}
-
-type QueueJob<T = unknown> = {
-    (...args: unknown[]): Promise<T | void>;
-};
-type RunOptions = {
-    controller?: AbortController;
-    name?: string;
-    description?: string;
-};
-type Events = {
-    jobDone: [result: unknown];
-    jobFailed: [error: Error];
-};
-declare class Queue {
-    #private;
-    readonly eventEmitter: EventEmitter<Events>;
-    constructor(maxParallel: number, debug?: boolean);
-    run<T>(job: QueueJob<T>, options?: RunOptions): Promise<T>;
-    runSync<T>(job: QueueJob<T>, options?: RunOptions): void;
-    get hasJobs(): boolean;
-    get count(): number;
-}
-
-export { EventEmitter as E, Queue as Q, type QueueJob as a };

package/dist/Queue-2-6pMcCx.d.ts

@@ -1,32 +0,0 @@
-declare class EventEmitter<TEvents extends Record<string, any>> {
-    #private;
-    constructor();
-    emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
-    on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-    off<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
-    removeAll(): void;
-}
-
-type QueueJob<T = unknown> = {
-    (...args: unknown[]): Promise<T | void>;
-};
-type RunOptions = {
-    controller?: AbortController;
-    name?: string;
-    description?: string;
-};
-type Events = {
-    jobDone: [result: unknown];
-    jobFailed: [error: Error];
-};
-declare class Queue {
-    #private;
-    readonly eventEmitter: EventEmitter<Events>;
-    constructor(maxParallel: number, debug?: boolean);
-    run<T>(job: QueueJob<T>, options?: RunOptions): Promise<T>;
-    runSync<T>(job: QueueJob<T>, options?: RunOptions): void;
-    get hasJobs(): boolean;
-    get count(): number;
-}
-
-export { EventEmitter as E, Queue as Q, type QueueJob as a };