@kubb/cli 3.0.0-alpha.4 → 3.0.0-alpha.6

package/src/utils/executeHooks.ts

@@ -7,6 +7,7 @@ import { ConsolaWritable } from './Writables.ts'
 
 import type { Config } from '@kubb/core'
 import { LogMapper } from '@kubb/core/logger'
+import PQueue from 'p-queue'
 
 type ExecutingHooksProps = {
   hooks: NonNullable<Config['hooks']>
@@ -15,37 +16,30 @@ type ExecutingHooksProps = {
 
 export async function executeHooks({ hooks, logger }: ExecutingHooksProps): Promise<void> {
   const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done].filter(Boolean)
+  const queue = new PQueue({ concurrency: 1 })
 
-  const executors = commands
-    .map(async (command) => {
-      const consolaWritable = new ConsolaWritable(logger.consola!, command)
-      const abortController = new AbortController()
-      const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
+  const promises = commands.map(async (command) => {
+    const consolaWritable = new ConsolaWritable(logger.consola!, command)
+    const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
 
-      if (!cmd) {
-        return null
-      }
+    if (!cmd) {
+      return null
+    }
 
+    await queue.add(async () => {
       logger.emit('start', `Executing hook ${logger.logLevel !== LogMapper.silent ? c.dim(command) : ''}`)
 
       const subProcess = await execa(cmd, _args, {
         detached: true,
-        cancelSignal: abortController.signal,
         stdout: logger.logLevel === LogMapper.silent ? undefined : ['pipe', consolaWritable],
+        stripFinalNewline: true,
       })
 
-      logger.emit('success', `Executing hook ${logger.logLevel !== LogMapper.silent ? c.dim(command) : ''}`)
-
-      if (subProcess) {
-        logger.emit('info', `Executing hooks\n ${subProcess.stdout}`)
-      }
-
-      consolaWritable.destroy()
-      return { subProcess, abort: abortController.abort.bind(abortController) }
+      logger.emit('success', `Executed hook ${logger.logLevel !== LogMapper.silent ? c.dim(command) : ''}`)
     })
-    .filter(Boolean)
+  })
 
-  await Promise.all(executors)
+  await Promise.all(promises)
 
-  logger.emit('success', 'Executing hooks')
+  logger.emit('success', 'Executed hooks')
 }

package/src/utils/getSummary.ts

@@ -6,7 +6,7 @@ import c from 'tinyrainbow'
 
 import { parseHrtimeToSeconds } from './parseHrtimeToSeconds.ts'
 
-import type { Config, PluginManager } from '@kubb/core'
+import type { Config, FileMetaBase, PluginManager } from '@kubb/core'
 import type { Logger } from '@kubb/core/logger'
 
 type SummaryProps = {
@@ -17,7 +17,7 @@ type SummaryProps = {
   logger: Logger
 }
 
-export function getSummary({ pluginManager, status, hrStart, config, logger }: SummaryProps): string[] {
+export function getSummary({ pluginManager, status, hrStart, config }: SummaryProps): string[] {
   const logs: string[] = []
   const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrStart))
 
@@ -29,7 +29,7 @@ export function getSummary({ pluginManager, status, hrStart, config, logger }: S
 
   const failedPlugins = config.plugins?.filter((plugin) => !buildEndPlugins.includes(plugin.name))?.map((plugin) => plugin.name)
   const pluginsCount = config.plugins?.length || 0
-  const files = pluginManager.fileManager.files.sort((a, b) => {
+  const files = pluginManager.fileManager.files.sort((a: { meta?: FileMetaBase }, b: { meta?: FileMetaBase }) => {
     if (!a.meta?.pluginKey?.[0] || !b.meta?.pluginKey?.[0]) {
       return 0
     }
@@ -49,22 +49,15 @@ export function getSummary({ pluginManager, status, hrStart, config, logger }: S
         : `${c.red(`${failedPlugins?.length ?? 1} failed`)}, ${pluginsCount} total`,
     pluginsFailed: status === 'failed' ? failedPlugins?.map((name) => randomCliColour(name))?.join(', ') : undefined,
     filesCreated: files.length,
-    time: `${c.yellow(`${elapsedSeconds}s`)} - finished at ${c.yellow(new Date().toLocaleString('en-GB', { timeZone: 'UTC' }))}`,
+    time: `${c.yellow(`${elapsedSeconds}s`)}`,
     output: path.isAbsolute(config.root) ? path.resolve(config.root, config.output.path) : config.root,
   } as const
 
-  logger.emit('debug', ['\nGenerated files:\n'])
-  logger.emit(
-    'debug',
-    files.map((file) => `${randomCliColour(JSON.stringify(file.meta?.pluginKey))} ${file.path}`),
-  )
-
   logs.push(
     [
       [`${c.bold('Plugins:')}        ${meta.plugins}`, true],
       [`${c.dim('Failed:')}          ${meta.pluginsFailed || 'none'}`, !!meta.pluginsFailed],
-      [`${c.bold('Generated:')}      ${meta.filesCreated} files`, true],
-      [`${c.bold('Time:')}           ${meta.time}`, true],
+      [`${c.bold('Generated:')}      ${meta.filesCreated} files in ${meta.time}`, true],
       [`${c.bold('Output:')}         ${meta.output}`, true],
     ]
       .map((item) => {

package/src/utils/writeLog.ts

@@ -1,11 +1,17 @@
 import { resolve } from 'node:path'
 import { read, write } from '@kubb/fs'
 
-export async function writeLog(data: string): Promise<string | undefined> {
+type Props = {
+  data: string
+  fileName?: string
+  override?: boolean
+}
+
+export async function writeLog({ data, override, fileName = 'kubb.log' }: Props): Promise<string | undefined> {
   if (data.trim() === '') {
     return undefined
   }
-  const path = resolve(process.cwd(), 'kubb-log.log')
+  const path = resolve(process.cwd(), fileName)
   let previousLogs = ''
 
   try {
@@ -14,5 +20,9 @@ export async function writeLog(data: string): Promise<string | undefined> {
     /* empty */
   }
 
-  return write(path, [previousLogs, data.trim()].filter(Boolean).join('\n\n\n'), { sanity: false })
+  if (override) {
+    return write(path, data.trim(), { sanity: false })
+  }
+
+  return write(path, [previousLogs, data.trim()].filter(Boolean).join('\n'), { sanity: false })
 }