@kubb/cli 5.0.0-beta.2 → 5.0.0-beta.21

package/src/runners/generate/run.ts

@@ -0,0 +1,316 @@
+import { createHash } from 'node:crypto'
+import path from 'node:path'
+import process from 'node:process'
+import { styleText } from 'node:util'
+import * as clack from '@clack/prompts'
+import type { AsyncEventEmitter } from '@internals/utils'
+import { AsyncEventEmitter as AsyncEventEmitterClass, detectFormatter, detectLinter, executeIfOnline, formatters, linters, toError } from '@internals/utils'
+import { type Config, createKubb, isInputPath, type KubbHooks, logLevel as logLevelMap } from '@kubb/core'
+import { version } from '../../../package.json'
+import { KUBB_NPM_PACKAGE_URL } from '../../constants.ts'
+import { setupLogger, type HookSinkFactory } from '../../loggers/utils.ts'
+import { buildTelemetryEvent, sendTelemetry } from '../../telemetry.ts'
+import { executeHooks, getConfigs, runHook, startWatcher } from './utils.ts'
+
+type GenerateProps = {
+  input?: string
+  config: Config
+  hooks: AsyncEventEmitter<KubbHooks>
+  logLevel: number
+  makeSink?: HookSinkFactory | null
+}
+
+type ToolMap = typeof formatters | typeof linters
+
+type RunToolPassOptions = {
+  toolValue: string
+  detect: () => Promise<string | null>
+  toolMap: ToolMap
+  toolLabel: string
+  successPrefix: string
+  noToolMessage: string
+  configName: string | undefined
+  outputPath: string
+  logLevel: number
+  hooks: AsyncEventEmitter<KubbHooks>
+  makeSink?: HookSinkFactory | null
+  onStart: () => Promise<void>
+  onEnd: () => Promise<void>
+}
+
+/**
+ * Registers a one-shot `kubb:hook:end` listener for `hookId` BEFORE the caller emits `kubb:hook:start`,
+ * avoiding the race where a synchronous emitter fires end before the listener is attached.
+ */
+function waitForHookEnd(
+  hooks: AsyncEventEmitter<KubbHooks>,
+  hookId: string,
+  onSuccess: () => Promise<void> | void,
+  fallbackErrorMessage: string,
+): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const handler = (ctx: { id?: string; command: string; args?: readonly string[]; success: boolean; error: Error | null }) => {
+      if (ctx.id !== hookId) return
+      hooks.off('kubb:hook:end', handler)
+      if (!ctx.success) {
+        reject(ctx.error ?? new Error(fallbackErrorMessage))
+        return
+      }
+      Promise.resolve(onSuccess()).then(resolve).catch(reject)
+    }
+    hooks.on('kubb:hook:end', handler)
+  })
+}
+
+async function runToolPass({
+  toolValue,
+  detect,
+  toolMap,
+  toolLabel,
+  successPrefix,
+  noToolMessage,
+  configName,
+  outputPath,
+  logLevel,
+  hooks,
+  makeSink,
+  onStart,
+  onEnd,
+}: RunToolPassOptions) {
+  await onStart()
+
+  let resolvedTool = toolValue
+  if (resolvedTool === 'auto') {
+    const detected = await detect()
+    if (!detected) {
+      await hooks.emit('kubb:warn', { message: noToolMessage })
+    } else {
+      resolvedTool = detected
+      await hooks.emit('kubb:info', { message: `Auto-detected ${toolLabel}: ${styleText('dim', resolvedTool)}` })
+    }
+  }
+
+  let toolError: Error | undefined
+
+  if (resolvedTool && resolvedTool !== 'auto' && resolvedTool in toolMap) {
+    const toolConfig = toolMap[resolvedTool as keyof ToolMap]
+    const hookId = createHash('sha256').update([configName, resolvedTool].filter(Boolean).join('-')).digest('hex')
+
+    const successMessage = [
+      `${successPrefix} with ${styleText('dim', resolvedTool)}`,
+      logLevel >= logLevelMap.info ? `on ${styleText('dim', outputPath)}` : undefined,
+      'successfully',
+    ]
+      .filter(Boolean)
+      .join(' ')
+
+    try {
+      const hookArgs = toolConfig.args(outputPath)
+      const commandWithArgs = [toolConfig.command, ...hookArgs].join(' ')
+      const hookEndPromise = waitForHookEnd(hooks, hookId, () => hooks.emit('kubb:success', { message: successMessage }), toolConfig.errorMessage)
+
+      await hooks.emit('kubb:hook:start', { id: hookId, command: toolConfig.command, args: hookArgs })
+
+      const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs, hookId) ?? {}
+
+      runHook({
+        id: hookId,
+        command: toolConfig.command,
+        args: hookArgs,
+        commandWithArgs,
+        context: hooks,
+        stream,
+        sink: { onLine, onStdout, onStderr },
+      }).catch(() => {})
+
+      await hookEndPromise
+    } catch (caughtError) {
+      const err = toError(caughtError)
+      await hooks.emit('kubb:error', { error: err })
+      toolError = err
+    }
+  }
+
+  await onEnd()
+
+  if (toolError) {
+    throw toolError
+  }
+}
+
+async function generate(options: GenerateProps): Promise<boolean> {
+  const { input, hooks, logLevel, makeSink } = options
+
+  const hrStart = process.hrtime()
+  const inputPath = input ?? (options.config.input && 'path' in options.config.input ? options.config.input.path : undefined)
+
+  const config: Config = {
+    ...options.config,
+    input: inputPath ? { ...options.config.input, path: inputPath } : options.config.input,
+    ...options.config.output,
+  } satisfies Config
+
+  const kubb = createKubb(config, { hooks })
+
+  await hooks.emit('kubb:generation:start', { config })
+  await hooks.emit('kubb:info', { message: config.name ? `Setup generation ${styleText('bold', config.name)}` : 'Setup generation', info: inputPath })
+
+  await kubb.setup()
+
+  await hooks.emit('kubb:info', { message: config.name ? `Build generation ${styleText('bold', config.name)}` : 'Build generation', info: inputPath })
+
+  const { files, failedPlugins, pluginTimings, error, driver } = await kubb.safeBuild()
+
+  await hooks.emit('kubb:info', { message: 'Load summary' })
+
+  const telemetryPlugins = Array.from(driver.plugins.values(), (p) => ({ name: p.name, options: p.options as Record<string, unknown> }))
+
+  const reportTelemetry = (status: 'success' | 'failed') =>
+    sendTelemetry(buildTelemetryEvent({ command: 'generate', kubbVersion: version, plugins: telemetryPlugins, hrStart, filesCreated: files.length, status }))
+
+  if (failedPlugins.size > 0 || error) {
+    const allErrors = [error, ...Array.from(failedPlugins, (it) => it.error)].filter(Boolean) as Error[]
+
+    for (const err of allErrors) {
+      await hooks.emit('kubb:error', { error: err })
+    }
+
+    await hooks.emit('kubb:generation:end', { config, storage: kubb.storage })
+    await hooks.emit('kubb:generation:summary', {
+      config,
+      failedPlugins,
+      filesCreated: files.length,
+      status: 'failed',
+      hrStart,
+      pluginTimings: logLevel >= logLevelMap.verbose ? pluginTimings : undefined,
+    })
+
+    await reportTelemetry('failed')
+    return false
+  }
+
+  await hooks.emit('kubb:success', { message: 'Generation succeeded', info: inputPath })
+  await hooks.emit('kubb:generation:end', { config, storage: kubb.storage })
+
+  const outputPath = path.resolve(config.root, config.output.path)
+
+  const toolPasses = [
+    config.output.format && {
+      toolValue: config.output.format,
+      detect: detectFormatter,
+      toolMap: formatters,
+      toolLabel: 'formatter',
+      successPrefix: 'Formatting',
+      noToolMessage: 'No formatter found (oxfmt, biome, or prettier). Skipping formatting.',
+      onStart: () => hooks.emit('kubb:format:start'),
+      onEnd: () => hooks.emit('kubb:format:end'),
+    },
+    config.output.lint && {
+      toolValue: config.output.lint,
+      detect: detectLinter,
+      toolMap: linters,
+      toolLabel: 'linter',
+      successPrefix: 'Linting',
+      noToolMessage: 'No linter found (oxlint, biome, or eslint). Skipping linting.',
+      onStart: () => hooks.emit('kubb:lint:start'),
+      onEnd: () => hooks.emit('kubb:lint:end'),
+    },
+  ].filter(Boolean) as Omit<RunToolPassOptions, 'configName' | 'outputPath' | 'logLevel' | 'hooks'>[]
+
+  for (const pass of toolPasses) {
+    await runToolPass({ ...pass, configName: config.name, outputPath, logLevel, hooks, makeSink })
+  }
+
+  if (config.hooks) {
+    await hooks.emit('kubb:hooks:start')
+    await executeHooks({ configHooks: config.hooks, hooks, makeSink })
+    await hooks.emit('kubb:hooks:end')
+  }
+
+  await hooks.emit('kubb:generation:summary', { config, failedPlugins, filesCreated: files.length, status: 'success', hrStart, pluginTimings })
+
+  await reportTelemetry('success')
+  return true
+}
+
+type GenerateCommandOptions = {
+  input?: string
+  configPath?: string
+  logLevel: string
+  watch: boolean
+}
+
+async function checkForUpdate(hooks: AsyncEventEmitter<KubbHooks>): Promise<void> {
+  await executeIfOnline(async () => {
+    try {
+      const res = await fetch(KUBB_NPM_PACKAGE_URL)
+      const data = (await res.json()) as { version: string }
+      if (data.version && version < data.version) {
+        await hooks.emit('kubb:version:new', { currentVersion: version, latestVersion: data.version })
+      }
+    } catch {
+      // Ignore network errors
+    }
+  })
+}
+
+/**
+ * Runs the full Kubb generation lifecycle for the given CLI options.
+ * Sets up the logger, checks for a newer version, loads configs, and calls `generate` for each config entry.
+ */
+export async function run({ input, configPath, logLevel: logLevelKey, watch }: GenerateCommandOptions): Promise<void> {
+  const logLevel = logLevelMap[logLevelKey as keyof typeof logLevelMap] ?? logLevelMap.info
+  const hooks = new AsyncEventEmitterClass<KubbHooks>()
+
+  const makeSink = await setupLogger(hooks, { logLevel })
+
+  await hooks.emit('kubb:lifecycle:start', { version })
+
+  await checkForUpdate(hooks)
+
+  try {
+    await hooks.emit('kubb:config:start')
+
+    const { configs, configPath: resolvedConfigPath } = await getConfigs({ configPath, input })
+    const relativeConfigPath = path.relative(process.cwd(), resolvedConfigPath)
+
+    await hooks.emit('kubb:info', { message: 'Config loaded', info: relativeConfigPath })
+    await hooks.emit('kubb:success', { message: 'Config loaded successfully', info: relativeConfigPath })
+    await hooks.emit('kubb:config:end', { configs })
+
+    let anyFailed = false
+    for (const config of configs) {
+      if (isInputPath(config) && watch) {
+        await startWatcher(
+          [input || config.input.path],
+          async (paths) => {
+            // Don't removeAll() — that would also drop logger and lifecycle listeners.
+            // Plugin and middleware listeners are already disposed by safeBuild's
+            // setupResult.dispose() in its finally block, so re-running generate()
+            // on the same hooks emitter is safe.
+            await generate({ input, config, logLevel, hooks, makeSink })
+            clack.log.step(styleText('yellow', `Watching for changes in ${paths.join(' and ')}`))
+          },
+          { info: (msg) => clack.log.info(msg), error: (msg) => clack.log.error(msg) },
+        )
+      } else {
+        try {
+          const succeeded = await generate({ input, config, logLevel, hooks, makeSink })
+          if (!succeeded) anyFailed = true
+        } catch (configError) {
+          await hooks.emit('kubb:error', { error: toError(configError) })
+          anyFailed = true
+        }
+      }
+    }
+
+    await hooks.emit('kubb:lifecycle:end')
+
+    if (anyFailed) {
+      process.exit(1)
+    }
+  } catch (error) {
+    await hooks.emit('kubb:error', { error: toError(error) })
+    process.exit(1)
+  }
+}

package/src/runners/generate/utils.ts

@@ -0,0 +1,216 @@
+import { createHash } from 'node:crypto'
+import { styleText } from 'node:util'
+import type { AsyncEventEmitter } from '@internals/utils'
+import { toError, tokenize } from '@internals/utils'
+import type { CLIOptions, Config, KubbHooks, PossibleConfig } from '@kubb/core'
+import { cosmiconfig } from 'cosmiconfig'
+import { createJiti } from 'jiti'
+import { NonZeroExitError, x } from 'tinyexec'
+import type { HookSinkFactory, HookSinkOptions } from '../../loggers/utils.ts'
+import { WATCHER_IGNORED_PATHS } from '../../constants.ts'
+
+type CosmiconfigResult = {
+  filepath: string
+  isEmpty?: boolean
+  config: PossibleConfig<CLIOptions>
+}
+
+const jiti = createJiti(import.meta.url, {
+  jsx: { runtime: 'automatic', importSource: '@kubb/renderer-jsx' },
+  moduleCache: false,
+})
+
+const tsLoader = (configFile: string) => jiti.import(configFile, { default: true })
+
+const MODULE_NAME = 'kubb'
+
+const BASE_SEARCH_PLACES = [
+  'package.json',
+  `.${MODULE_NAME}rc`,
+  `.${MODULE_NAME}rc.json`,
+  `.${MODULE_NAME}rc.yaml`,
+  `.${MODULE_NAME}rc.yml`,
+  `.${MODULE_NAME}rc.ts`,
+  `.${MODULE_NAME}rc.mts`,
+  `.${MODULE_NAME}rc.cts`,
+  `.${MODULE_NAME}rc.js`,
+  `.${MODULE_NAME}rc.mjs`,
+  `.${MODULE_NAME}rc.cjs`,
+  `${MODULE_NAME}.config.ts`,
+  `${MODULE_NAME}.config.mts`,
+  `${MODULE_NAME}.config.cts`,
+  `${MODULE_NAME}.config.js`,
+  `${MODULE_NAME}.config.mjs`,
+  `${MODULE_NAME}.config.cjs`,
+]
+
+const SEARCH_PLACES = ['', '.config/', 'configs/'].flatMap((prefix) => BASE_SEARCH_PLACES.map((p) => `${prefix}${p}`))
+
+async function getCosmiConfig(configFile?: string): Promise<CosmiconfigResult> {
+  const explorer = cosmiconfig(MODULE_NAME, {
+    cache: false,
+    searchPlaces: SEARCH_PLACES,
+    loaders: { '.ts': tsLoader, '.mts': tsLoader, '.cts': tsLoader },
+  })
+
+  let result: CosmiconfigResult
+  try {
+    result = (configFile ? await explorer.load(configFile) : await explorer.search()) as CosmiconfigResult
+  } catch (error) {
+    throw new Error('Config failed loading', { cause: error })
+  }
+
+  if (!result?.config || result.isEmpty) {
+    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
+  }
+
+  return result
+}
+
+type GetConfigsOptions = {
+  /**
+   * Explicit path to the Kubb config file. When omitted, cosmiconfig searches from the current directory.
+   */
+  configPath?: string
+  /**
+   * Optional OpenAPI input path that overrides `config.input.path` for this run.
+   */
+  input?: string
+}
+
+type GetConfigsResult = {
+  /**
+   * Absolute path to the resolved config file.
+   */
+  configPath: string
+  /**
+   * Resolved and normalized array of Kubb configs, each guaranteed to have a `plugins` array.
+   */
+  configs: Array<Config>
+}
+
+/**
+ * Discovers the Kubb config via cosmiconfig and resolves it into a normalized array of configs.
+ * Every config in the result is guaranteed to have a `plugins` array.
+ */
+export async function getConfigs({ configPath, input }: GetConfigsOptions): Promise<GetConfigsResult> {
+  const result = await getCosmiConfig(configPath)
+  const resolved = await (typeof result.config === 'function' ? result.config({ input } as CLIOptions) : result.config)
+  const userConfigs = Array.isArray(resolved) ? resolved : [resolved]
+
+  return {
+    configPath: result.filepath,
+    configs: userConfigs.map((item) => ({ ...item, plugins: item.plugins ?? [] }) as Config),
+  }
+}
+
+type ExecuteHooksOptions = {
+  configHooks: NonNullable<Config['hooks']>
+  hooks: AsyncEventEmitter<KubbHooks>
+  makeSink?: HookSinkFactory | null
+}
+
+/**
+ * Runs the `done` hooks defined in a Kubb config in sequence.
+ */
+export async function executeHooks({ configHooks, hooks, makeSink }: ExecuteHooksOptions): Promise<void> {
+  const commands = Array.isArray(configHooks.done) ? configHooks.done : [configHooks.done].filter(Boolean)
+
+  for (const command of commands) {
+    const [cmd, ...args] = tokenize(command)
+    if (!cmd) continue
+
+    const hookId = createHash('sha256').update(command).digest('hex')
+    const commandWithArgs = [cmd, ...args].join(' ')
+
+    await hooks.emit('kubb:hook:start', { id: hookId, command: cmd, args })
+
+    const { stream = false, onLine, onStdout, onStderr } = makeSink?.(commandWithArgs, hookId) ?? {}
+    await runHook({ id: hookId, command: cmd, args, commandWithArgs, context: hooks, stream, sink: { onLine, onStdout, onStderr } })
+  }
+}
+
+type RunHookOptions = {
+  id: string
+  command: string
+  args?: readonly string[]
+  commandWithArgs: string
+  context: AsyncEventEmitter<KubbHooks>
+  stream?: boolean
+  sink?: HookSinkOptions
+}
+
+export async function runHook({ id, command, args, commandWithArgs, context, stream = false, sink }: RunHookOptions): Promise<void> {
+  const emitEnd = (success: boolean, error: Error | null) => context.emit('kubb:hook:end', { command, args, id, success, error })
+
+  try {
+    const proc = x(command, [...(args ?? [])], {
+      nodeOptions: { detached: process.platform !== 'win32' },
+      throwOnError: true,
+    })
+
+    if (stream && sink?.onLine) {
+      for await (const line of proc) {
+        sink.onLine(line)
+      }
+    }
+
+    const result = await proc
+    await context.emit('kubb:debug', { date: new Date(), logs: [result.stdout.trimEnd()] })
+    await context.emit('kubb:success', { message: `${styleText('dim', commandWithArgs)} successfully executed` })
+    await emitEnd(true, null)
+  } catch (err) {
+    if (!(err instanceof NonZeroExitError)) {
+      const error = toError(err)
+      await emitEnd(false, error)
+      await context.emit('kubb:error', { error })
+      return
+    }
+
+    const stderr = err.output?.stderr ?? ''
+    const stdout = err.output?.stdout ?? ''
+
+    await context.emit('kubb:debug', { date: new Date(), logs: [stdout, stderr].filter(Boolean) })
+
+    if (stderr) sink?.onStderr?.(stderr)
+    if (stdout) sink?.onStdout?.(stdout)
+
+    const error = new Error(`Hook execute failed: ${commandWithArgs}`)
+    await emitEnd(false, error)
+    await context.emit('kubb:error', { error })
+  }
+}
+
+type WatcherLog = {
+  info: (message: string) => void
+  error: (message: string) => void
+}
+
+/**
+ * Starts a file watcher on the given paths and calls `cb` on any change.
+ * Ignores `.git` and `node_modules` directories.
+ */
+export async function startWatcher(
+  path: string[],
+  cb: (path: string[]) => Promise<void>,
+  log: WatcherLog = { info: console.log, error: console.log },
+): Promise<void> {
+  const { watch } = await import('chokidar')
+  const watcher = watch(path, { ignorePermissionErrors: true, ignored: WATCHER_IGNORED_PATHS })
+
+  process.once('SIGINT', () => {
+    watcher.close()
+  })
+  process.once('SIGTERM', () => {
+    watcher.close()
+  })
+
+  watcher.on('all', async (type, file) => {
+    log.info(styleText('yellow', styleText('bold', `Change detected: ${type} ${file}`)))
+    try {
+      await cb(path)
+    } catch (_e) {
+      log.error(styleText('red', 'Watcher failed'))
+    }
+  })
+}