@kubb/cli 3.0.0-alpha.1 → 3.0.0-alpha.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/cli",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.11",
   "description": "Generator cli",
   "keywords": [
     "typescript",
@@ -18,9 +18,6 @@
   "author": "Stijn Van Hulle <stijn@stijnvanhulle.be",
   "sideEffects": false,
   "type": "module",
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -28,9 +25,12 @@
       "default": "./dist/index.cjs"
     }
   },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
   "bin": {
-    "kubb": "bin/kubb.cjs",
-    "bkubb": "bin/bkubb.cjs"
+    "bkubb": "bin/bkubb.cjs",
+    "kubb": "bin/kubb.cjs"
   },
   "files": [
     "src",
@@ -43,28 +43,30 @@
     "bundle-require": "^5.0.0",
     "chokidar": "^3.6.0",
     "citty": "^0.1.6",
+    "cli-progress": "^3.12.0",
     "consola": "^3.2.3",
     "cosmiconfig": "^9.0.0",
     "esbuild": "^0.23.1",
     "execa": "^9.3.1",
     "js-runtime": "^0.0.8",
     "latest-version": "^9.0.0",
-    "ora": "^8.0.1",
+    "p-queue": "^8.0.1",
     "semver": "^7.6.3",
     "string-argv": "^0.3.2",
     "tinyrainbow": "^1.2.0",
-    "@kubb/core": "3.0.0-alpha.1",
-    "@kubb/fs": "3.0.0-alpha.1"
+    "@kubb/core": "3.0.0-alpha.11",
+    "@kubb/fs": "3.0.0-alpha.11"
   },
   "devDependencies": {
-    "@types/node": "^20.16.1",
+    "@types/cli-progress": "^3.11.6",
+    "@types/node": "^20.16.2",
     "@types/semver": "^7.5.8",
     "source-map-support": "^0.5.21",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4",
-    "@kubb/config-ts": "3.0.0-alpha.1",
-    "@kubb/config-tsup": "3.0.0-alpha.1",
-    "@kubb/plugin-oas": "3.0.0-alpha.1"
+    "@kubb/config-ts": "3.0.0-alpha.11",
+    "@kubb/config-tsup": "3.0.0-alpha.11",
+    "@kubb/plugin-oas": "3.0.0-alpha.11"
   },
   "engines": {
     "node": ">=20"

package/src/commands/generate.ts

@@ -1,16 +1,15 @@
-import { LogLevel } from '@kubb/core/logger'
 import { defineCommand, showUsage } from 'citty'
 import type { ArgsDef, ParsedArgs } from 'citty'
 import { execa } from 'execa'
 import c from 'tinyrainbow'
 
-import path from 'node:path'
 import { getConfig } from '../utils/getConfig.ts'
 import { getCosmiConfig } from '../utils/getCosmiConfig.ts'
-import { spinner } from '../utils/spinner.ts'
 import { startWatcher } from '../utils/watcher.ts'
 
+import path from 'node:path'
 import { PromiseManager, isInputPath } from '@kubb/core'
+import { LogMapper, createLogger } from '@kubb/core/logger'
 import { generate } from '../generate.ts'
 
 const args = {
@@ -23,8 +22,8 @@ const args = {
     type: 'string',
     description: 'Info, silent or debug',
     alias: 'l',
-    default: LogLevel.info,
-    valueHint: `${LogLevel.silent}|${LogLevel.info}|${LogLevel.debug}`,
+    default: 'info',
+    valueHint: 'silent|info|debug',
   },
   watch: {
     type: 'boolean',
@@ -60,9 +59,6 @@ const command = defineCommand({
     description: "[input] Generate files based on a 'kubb.config.ts' file",
   },
   args,
-  setup() {
-    spinner.start('🔍 Loading config')
-  },
   async run({ args }) {
     const input = args._[0]
 
@@ -72,7 +68,7 @@ const command = defineCommand({
     }
 
     if (args.debug) {
-      args.logLevel = LogLevel.debug
+      args.logLevel = 'debug'
     }
 
     if (args.bun) {
@@ -82,8 +78,15 @@ const command = defineCommand({
       return
     }
 
+    const logLevel = LogMapper[args.logLevel as keyof typeof LogMapper] || 3
+    const logger = createLogger({
+      logLevel,
+    })
+
+    logger.emit('start', 'Loading config')
+
     const result = await getCosmiConfig('kubb', args.config)
-    spinner.succeed(`🔍 Config loaded(${c.dim(path.relative(process.cwd(), result.filepath))})`)
+    logger.emit('success', `Config loaded(${c.dim(path.relative(process.cwd(), result.filepath))})`)
 
     const config = await getConfig(result, args)
 
@@ -94,9 +97,8 @@ const command = defineCommand({
 
       if (isInputPath(config)) {
         return startWatcher([input || config.input.path], async (paths) => {
-          await generate({ config, args })
-          spinner.spinner = 'simpleDotsScrolling'
-          spinner.start(c.yellow(c.bold(`Watching for changes in ${paths.join(' and ')}`)))
+          await generate({ config, args, input })
+          logger.emit('start', c.yellow(c.bold(`Watching for changes in ${paths.join(' and ')}`)))
         })
       }
     }

package/src/generate.ts

@@ -1,16 +1,15 @@
-import { LogLevel, LogMapper, createLogger, randomCliColour } from '@kubb/core/logger'
+import { LogMapper } from '@kubb/core/logger'
 
 import c from 'tinyrainbow'
 
-import { spinner } from './utils/spinner.ts'
-
-import { type Config, Warning, safeBuild } from '@kubb/core'
-import { createConsola } from 'consola'
-import type { Args } from './commands/generate.ts'
+import { type Config, safeBuild } from '@kubb/core'
 import { executeHooks } from './utils/executeHooks.ts'
 import { getErrorCauses } from './utils/getErrorCauses.ts'
 import { getSummary } from './utils/getSummary.ts'
-import { writeLog } from './utils/writeLog.ts'
+
+import { Presets, SingleBar } from 'cli-progress'
+import type { Args } from './commands/generate.ts'
+import { createLogger } from '@kubb/core/logger'
 
 type GenerateProps = {
   input?: string
@@ -19,48 +18,49 @@ type GenerateProps = {
 }
 
 export async function generate({ input, config, args }: GenerateProps): Promise<void> {
-  const logLevel = (args.logLevel as LogLevel) || LogLevel.silent
+  const logLevel = LogMapper[args.logLevel as keyof typeof LogMapper] || 3
   const logger = createLogger({
     logLevel,
     name: config.name,
-    spinner,
-    consola: createConsola({
-      level: LogMapper[logLevel] || 3,
-    }),
   })
+  const { root = process.cwd(), ...userConfig } = config
+  const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
 
-  logger.on('debug', async (messages: string[]) => {
-    if (logLevel === LogLevel.debug) {
-      await writeLog(messages.join('\n'))
-    }
-  })
-
-  logger.consola?.wrapConsole()
-
-  if (logger.name) {
-    spinner.prefixText = randomCliColour(logger.name)
-  }
-
-  const hrstart = process.hrtime()
-
-  if (args.logLevel === LogLevel.debug) {
-    const { performance, PerformanceObserver } = await import('node:perf_hooks')
+  if (logger.logLevel !== LogMapper.debug) {
+    const progressCache = new Map<string, SingleBar>()
+
+    logger.on('progress_start', ({ id, size, message = '' }) => {
+      logger.consola?.pauseLogs()
+      const payload = { id, message }
+      const progressBar = new SingleBar(
+        {
+          format: '{percentage}% {bar} {value}/{total} | {message}',
+          barsize: 30,
+          clearOnComplete: true,
+          emptyOnZero: true,
+        },
+        Presets.shades_grey,
+      )
+
+      if (!progressCache.has(id)) {
+        progressCache.set(id, progressBar)
+        progressBar.start(size, 1, payload)
+      }
+    })
 
-    const performanceOpserver = new PerformanceObserver((items) => {
-      const message = `${items.getEntries()[0]?.duration.toFixed(0)}ms`
+    logger.on('progress_stop', ({ id }) => {
+      progressCache.get(id)?.stop()
+      logger.consola?.resumeLogs()
+    })
 
-      spinner.suffixText = c.yellow(message)
+    logger.on('progressed', ({ id, message = '' }) => {
+      const payload = { id, message }
 
-      performance.clearMarks()
+      progressCache.get(id)?.increment(1, payload)
     })
-
-    performanceOpserver.observe({ type: 'measure' })
   }
 
-  const { root = process.cwd(), ...userConfig } = config
-  const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
-
-  spinner.start(`🚀 Building ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+  logger.emit('start', `Building ${logger.logLevel !== LogMapper.silent ? c.dim(inputPath) : ''}`)
 
   const definedConfig: Config = {
     root,
@@ -73,37 +73,50 @@ export async function generate({ input, config, args }: GenerateProps): Promise<
       : userConfig.input,
     output: {
       write: true,
+      exportType: 'barrelNamed',
       ...userConfig.output,
     },
   }
-  const { pluginManager, error } = await safeBuild({
+  const hrStart = process.hrtime()
+  const { pluginManager, files, error } = await safeBuild({
     config: definedConfig,
     logger,
   })
 
+  if (logger.logLevel === LogMapper.debug) {
+    logger.consola?.start('Writing logs')
+
+    const logFiles = await logger.writeLogs()
+
+    logger.consola?.success(`Written logs: \n${logFiles.join('\n')}`)
+  }
+
   const summary = getSummary({
+    filesCreated: files.length,
     pluginManager,
     config: definedConfig,
     status: error ? 'failed' : 'success',
-    hrstart,
-    logger,
+    hrStart,
   })
 
-  if (error) {
-    spinner.suffixText = ''
-    spinner.fail(`🚀 Build failed ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
-
-    console.log(summary.join(''))
-
-    if (error instanceof Warning) {
-      spinner.warn(c.yellow(error.message))
-      process.exit(0)
-    }
+  if (error && logger.consola) {
+    logger.consola?.resumeLogs()
+    logger.consola.error(`Build failed ${logger.logLevel !== LogMapper.silent ? c.dim(inputPath) : ''}`)
+
+    logger.consola.box({
+      title: `${config.name || ''}`,
+      message: summary.join(''),
+      style: {
+        padding: 2,
+        borderColor: 'red',
+        borderStyle: 'rounded',
+      },
+    })
 
     const errors = getErrorCauses([error])
-    if (logger.consola && errors.length && logLevel === LogLevel.debug) {
+    if (logger.consola && errors.length && logger.logLevel === LogMapper.debug) {
       errors.forEach((err) => {
-        logger.consola!.error(err)
+        logger.consola?.error(err)
       })
     }
 
@@ -112,10 +125,19 @@ export async function generate({ input, config, args }: GenerateProps): Promise<
     process.exit(0)
   }
 
-  await executeHooks({ hooks: config.hooks, logLevel })
+  if (config.hooks) {
+    await executeHooks({ hooks: config.hooks, logger })
+  }
 
-  spinner.suffixText = ''
-  spinner.succeed(`🚀 Build completed ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+  logger.consola?.log(`⚡Build completed ${logger.logLevel !== LogMapper.silent ? c.dim(inputPath) : ''}`)
 
-  console.log(summary.join(''))
+  logger.consola?.box({
+    title: `${config.name || ''}`,
+    message: summary.join(''),
+    style: {
+      padding: 2,
+      borderColor: 'green',
+      borderStyle: 'rounded',
+    },
+  })
 }

package/src/index.ts

@@ -2,8 +2,8 @@ import { defineCommand, runCommand, runMain } from 'citty'
 import getLatestVersion from 'latest-version'
 import { lt } from 'semver'
 
-import consola from 'consola'
 import { version } from '../package.json'
+import consola from 'consola'
 
 const name = 'kubb'
 

package/src/utils/Writables.ts

@@ -0,0 +1,23 @@
+import { Writable } from 'node:stream'
+
+import c from 'tinyrainbow'
+
+import * as process from 'node:process'
+import type { WritableOptions } from 'node:stream'
+import type { ConsolaInstance } from 'consola'
+
+export class ConsolaWritable extends Writable {
+  consola: ConsolaInstance | undefined
+  command: string
+  constructor(consola: ConsolaInstance | undefined, command: string, opts?: WritableOptions) {
+    super(opts)
+
+    this.command = command
+    this.consola = consola
+  }
+  _write(chunk: any, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+    process.stdout.write(`${c.dim(chunk?.toString())}`)
+
+    callback()
+  }
+}

package/src/utils/executeHooks.ts

@@ -1,65 +1,45 @@
-import { LogLevel } from '@kubb/core/logger'
+import type { Logger } from '@kubb/core/logger'
 import { execa } from 'execa'
 import { parseArgsStringToArgv } from 'string-argv'
 import c from 'tinyrainbow'
 
-import { OraWritable } from './OraWritable.ts'
-import { spinner } from './spinner.ts'
+import { ConsolaWritable } from './Writables.ts'
 
-import type { Writable } from 'node:stream'
 import type { Config } from '@kubb/core'
+import { LogMapper } from '@kubb/core/logger'
+import PQueue from 'p-queue'
 
 type ExecutingHooksProps = {
-  hooks: Config['hooks']
-  logLevel: LogLevel
+  hooks: NonNullable<Config['hooks']>
+  logger: Logger
 }
 
-export async function executeHooks({ hooks, logLevel }: ExecutingHooksProps): Promise<void> {
-  if (!hooks?.done) {
-    return
-  }
+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 commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done]
+  const promises = commands.map(async (command) => {
+    const consolaWritable = new ConsolaWritable(logger.consola!, command)
+    const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
 
-  if (logLevel === LogLevel.silent) {
-    spinner.start('Executing hooks')
-  }
+    if (!cmd) {
+      return null
+    }
 
-  const executers = commands
-    .map(async (command) => {
-      const oraWritable = new OraWritable(spinner, command)
-      const abortController = new AbortController()
-      const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
+    await queue.add(async () => {
+      logger?.emit('start', `Executing hook ${logger.logLevel !== LogMapper.silent ? c.dim(command) : ''}`)
 
-      if (!cmd) {
-        return null
-      }
-
-      spinner.start(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
-
-      const subProcess = await execa(cmd, _args, {
+      await execa(cmd, _args, {
         detached: true,
-        cancelSignal: abortController.signal,
-        stdout: ['pipe', oraWritable],
+        stdout: logger?.logLevel === LogMapper.silent ? undefined : ['pipe', consolaWritable],
+        stripFinalNewline: true,
       })
-      spinner.suffixText = ''
-
-      if (logLevel === LogLevel.silent) {
-        spinner.succeed(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
-
-        if (subProcess) {
-          console.log(subProcess.stdout)
-        }
-      }
 
-      oraWritable.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(executers)
+  await Promise.all(promises)
 
-  if (logLevel === LogLevel.silent) {
-    spinner.succeed('Executing hooks')
-  }
+  logger?.emit('success', 'Executed hooks')
 }

package/src/utils/getPlugins.ts

@@ -1,5 +1,3 @@
-import { PackageManager } from '@kubb/core'
-
 import type { UserConfig } from '@kubb/core'
 
 function isJSONPlugins(plugins: UserConfig['plugins']) {
@@ -12,14 +10,6 @@ function isObjectPlugins(plugins: UserConfig['plugins']): plugins is any {
   return plugins instanceof Object && !Array.isArray(plugins)
 }
 
-async function importPlugin(name: string, options: object): Promise<UserConfig['plugins']> {
-  const packageManager = new PackageManager(process.cwd())
-
-  const importedPlugin: any = process.env.NODE_ENV === 'test' ? await import(name) : await packageManager.import(name)
-
-  return importedPlugin?.default ? importedPlugin.default(options) : importedPlugin(options)
-}
-
 export function getPlugins(plugins: UserConfig['plugins']): Promise<UserConfig['plugins']> {
   if (isObjectPlugins(plugins)) {
     throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/getting-started/configure#json')

package/src/utils/getSummary.ts

@@ -7,20 +7,18 @@ import c from 'tinyrainbow'
 import { parseHrtimeToSeconds } from './parseHrtimeToSeconds.ts'
 
 import type { Config, PluginManager } from '@kubb/core'
-import type { Logger } from '@kubb/core/logger'
 
 type SummaryProps = {
   pluginManager: PluginManager
   status: 'success' | 'failed'
-  hrstart: [number, number]
+  hrStart: [number, number]
+  filesCreated: number
   config: Config
-  logger: Logger
 }
 
-export function getSummary({ pluginManager, status, hrstart, config, logger }: SummaryProps): string[] {
-  const { logLevel } = logger
+export function getSummary({ pluginManager, filesCreated, status, hrStart, config }: SummaryProps): string[] {
   const logs: string[] = []
-  const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrstart))
+  const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrStart))
 
   const buildStartPlugins = pluginManager.executed
     .filter((item) => item.hookName === 'buildStart' && item.plugin.name !== 'core')
@@ -30,48 +28,24 @@ 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) => {
-    if (!a.meta?.pluginKey?.[0] || !b.meta?.pluginKey?.[0]) {
-      return 0
-    }
-    if (a.meta?.pluginKey?.[0]?.length < b.meta?.pluginKey?.[0]?.length) {
-      return 1
-    }
-    if (a.meta?.pluginKey?.[0]?.length > b.meta?.pluginKey?.[0]?.length) {
-      return -1
-    }
-    return 0
-  })
 
   const meta = {
-    name: config.name,
     plugins:
       status === 'success'
         ? `${c.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total`
         : `${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`),
-    endTime: c.yellow(Date()),
+    filesCreated: filesCreated,
+    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(
     [
-      ['\n', true],
-      [`     ${c.bold('Name:')}      ${meta.name}`, !!meta.name],
-      [`  ${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('Ended:')}      ${meta.endTime}`, true],
-      [`   ${c.bold('Output:')}      ${meta.output}`, true],
+      [`${c.bold('Plugins:')}        ${meta.plugins}`, true],
+      [`${c.dim('Failed:')}          ${meta.pluginsFailed || 'none'}`, !!meta.pluginsFailed],
+      [`${c.bold('Generated:')}      ${meta.filesCreated} files in ${meta.time}`, true],
+      [`${c.bold('Output:')}         ${meta.output}`, true],
     ]
       .map((item) => {
         if (item.at(1)) {

package/src/utils/watcher.ts

@@ -1,9 +1,9 @@
 import c from 'tinyrainbow'
-
-import { spinner } from './spinner.ts'
+import { createLogger } from '@kubb/core/logger'
 
 export async function startWatcher(path: string[], cb: (path: string[]) => Promise<void>): Promise<void> {
   const { watch } = await import('chokidar')
+  const logger = createLogger()
 
   const ignored = ['**/{.git,node_modules}/**']
 
@@ -12,14 +12,12 @@ export async function startWatcher(path: string[], cb: (path: string[]) => Promi
     ignored,
   })
   watcher.on('all', (type, file) => {
-    spinner.succeed(c.yellow(c.bold(`Change detected: ${type} ${file}`)))
-    // revert back
-    spinner.spinner = 'clock'
+    logger?.emit('info', c.yellow(c.bold(`Change detected: ${type} ${file}`)))
 
     try {
       cb(path)
     } catch (e) {
-      spinner.warn(c.red('Watcher failed'))
+      logger?.emit('warning', c.red('Watcher failed'))
     }
   })