@kubb/cli 2.0.0-canary.20231030T125136 → 2.0.0

package/src/generate.ts

@@ -0,0 +1,137 @@
+import { safeBuild } from '@kubb/core'
+import { createLogger, LogLevel, randomCliColour } from '@kubb/core/logger'
+
+import { execa } from 'execa'
+import { parseArgsStringToArgv } from 'string-argv'
+import c from 'tinyrainbow'
+
+import { getSummary } from './utils/getSummary.ts'
+import { OraWritable } from './utils/OraWritable.ts'
+import { spinner } from './utils/spinner.ts'
+
+import type { Writable } from 'node:stream'
+import type { CLIOptions, KubbConfig } from '@kubb/core'
+import type { ExecaReturnValue } from 'execa'
+
+type GenerateProps = {
+  input?: string
+  config: KubbConfig
+  CLIOptions: CLIOptions
+}
+
+type ExecutingHooksProps = {
+  hooks: KubbConfig['hooks']
+  logLevel: LogLevel
+}
+
+type Executer = { subProcess: ExecaReturnValue<string>; abort: AbortController['abort'] }
+
+async function executeHooks({ hooks, logLevel }: ExecutingHooksProps): Promise<void> {
+  if (!hooks?.done) {
+    return
+  }
+
+  const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done]
+
+  if (logLevel === LogLevel.silent) {
+    spinner.start(`Executing hooks`)
+  }
+
+  const executers: Promise<Executer | null>[] = commands
+    .map(async (command) => {
+      const oraWritable = new OraWritable(spinner, command)
+      const abortController = new AbortController()
+      const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
+
+      if (!cmd) {
+        return null
+      }
+
+      spinner.start(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
+
+      const subProcess = await execa(cmd, _args, { detached: true, signal: abortController.signal }).pipeStdout!(oraWritable as Writable)
+      spinner.suffixText = ''
+
+      if (logLevel === LogLevel.silent) {
+        spinner.succeed(`Executing hook ${logLevel !== 'silent' ? c.dim(command) : ''}`)
+
+        console.log(subProcess.stdout)
+      }
+
+      oraWritable.destroy()
+      return { subProcess, abort: abortController.abort.bind(abortController) }
+    })
+    .filter(Boolean)
+
+  await Promise.all(executers)
+
+  if (logLevel === LogLevel.silent) {
+    spinner.succeed(`Executing hooks`)
+  }
+}
+
+export async function generate({ input, config, CLIOptions }: GenerateProps): Promise<void> {
+  const logger = createLogger({ logLevel: CLIOptions.logLevel || LogLevel.silent, name: config.name, spinner })
+
+  if (logger.name) {
+    spinner.prefixText = randomCliColour(logger.name)
+  }
+
+  const hrstart = process.hrtime()
+
+  if (CLIOptions.logLevel === LogLevel.debug) {
+    const { performance, PerformanceObserver } = await import('node:perf_hooks')
+
+    const performanceOpserver = new PerformanceObserver((items) => {
+      const message = `${items.getEntries()[0]?.duration.toFixed(0)}ms`
+
+      spinner.suffixText = c.yellow(message)
+
+      performance.clearMarks()
+    })
+
+    performanceOpserver.observe({ type: 'measure' })
+  }
+
+  const { root: _root, ...userConfig } = config
+  const logLevel = logger.logLevel
+  const inputPath = input ?? ('path' in userConfig.input ? userConfig.input.path : undefined)
+
+  spinner.start(`🚀 Building ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+
+  const { pluginManager, error } = await safeBuild({
+    config: {
+      root: process.cwd(),
+      ...userConfig,
+      input: inputPath
+        ? {
+          ...userConfig.input,
+          path: inputPath,
+        }
+        : userConfig.input,
+      output: {
+        write: true,
+        ...userConfig.output,
+      },
+    },
+    logger,
+  })
+
+  const summary = getSummary({ pluginManager, config, status: error ? 'failed' : 'success', hrstart, logger })
+
+  if (error) {
+    spinner.suffixText = ''
+    spinner.fail(`🚀 Build failed ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+
+    console.log(summary.join(''))
+
+    throw error
+  }
+
+  await executeHooks({ hooks: config.hooks, logLevel })
+
+  spinner.suffixText = ''
+  spinner.succeed(`🚀 Build completed ${logLevel !== 'silent' ? c.dim(inputPath) : ''}`)
+
+  console.log(summary.join(''))
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+import path from 'node:path'
+
+import { isInputPath, PromiseManager, Warning } from '@kubb/core'
+
+import { cac } from 'cac'
+import c from 'tinyrainbow'
+
+import { version } from '../package.json'
+import { getConfig } from './utils/getConfig.ts'
+import { getCosmiConfig } from './utils/getCosmiConfig.ts'
+import { renderErrors } from './utils/renderErrors.ts'
+import { spinner } from './utils/spinner.ts'
+import { startWatcher } from './utils/watcher.ts'
+import { generate } from './generate.ts'
+import { init } from './init.ts'
+
+import type { CLIOptions } from '@kubb/core'
+
+const moduleName = 'kubb'
+
+function programCatcher(e: unknown, CLIOptions: CLIOptions): void {
+  const error = e as Error
+  const message = renderErrors(error, { logLevel: CLIOptions.logLevel })
+
+  if (error instanceof Warning) {
+    spinner.warn(c.yellow(error.message))
+    process.exit(0)
+  }
+
+  spinner.fail(message)
+  process.exit(1)
+}
+
+async function generateAction(input: string, CLIOptions: CLIOptions) {
+  spinner.start('🔍 Loading config')
+  const result = await getCosmiConfig(moduleName, CLIOptions.config)
+  spinner.succeed(`🔍 Config loaded(${c.dim(path.relative(process.cwd(), result.filepath))})`)
+
+  const config = await getConfig(result, CLIOptions)
+
+  if (CLIOptions.watch) {
+    if (Array.isArray(config)) {
+      throw new Error('Cannot use watcher with multiple KubbConfigs(array)')
+    }
+
+    if (isInputPath(config)) {
+      return startWatcher([input || config.input.path], async (paths) => {
+        await generate({ config, CLIOptions })
+        spinner.spinner = 'simpleDotsScrolling'
+        spinner.start(c.yellow(c.bold(`Watching for changes in ${paths.join(' and ')}`)))
+      })
+    }
+  }
+
+  if (Array.isArray(config)) {
+    const promiseManager = new PromiseManager()
+    const promises = config.map((item) => () => generate({ input, config: item, CLIOptions }))
+
+    await promiseManager.run('seq', promises)
+
+    return
+  }
+
+  await generate({ input, config, CLIOptions })
+}
+
+export async function run(argv?: string[]): Promise<void> {
+  const program = cac(moduleName)
+
+  program.command('[input]', 'Path of the input file(overrides the one in `kubb.config.js`)').action(generateAction)
+
+  program
+    .command('generate [input]', 'Path of the input file(overrides the one in `kubb.config.js`)')
+    .option('-c, --config <path>', 'Path to the Kubb config')
+    .option('-l, --log-level <type>', 'Info, silent or debug')
+    .option('-w, --watch', 'Watch mode based on the input file')
+    .action(generateAction)
+
+  program.command('init', 'Init Kubb').action(async () => {
+    return init({ logLevel: 'info' })
+  })
+
+  program.help()
+  program.version(version)
+  program.parse(argv, { run: false })
+
+  try {
+    await program.runMatchedCommand()
+
+    process.exit(0)
+  } catch (e) {
+    programCatcher(e, program.options)
+  }
+}
+
+export default run

package/src/init.ts

@@ -0,0 +1,95 @@
+import path from 'node:path'
+
+import { write } from '@kubb/core/fs'
+import { LogLevel } from '@kubb/core/logger'
+import { isPromiseFulfilledResult } from '@kubb/core/utils'
+
+import { $ } from 'execa'
+import c from 'tinyrainbow'
+
+import { spinner } from './utils/spinner.ts'
+
+type Preset = 'simple'
+
+type PackageManager = 'pnpm' | 'npm' | 'yarn'
+
+type PresetMeta = {
+  'kubb.config': string
+  packages: string[]
+}
+
+type InitProps = {
+  /**
+   * @default `'silent'`
+   */
+  logLevel?: LogLevel
+  /**
+   * @default `'simple'`
+   */
+  preset?: Preset
+  /**
+   * @default `'pnpm'`
+   */
+  packageManager?: PackageManager
+}
+
+const presets: Record<Preset, PresetMeta> = {
+  simple: {
+    'kubb.config': `
+import { defineConfig } from '@kubb/core'
+import createSwagger from '@kubb/swagger'
+import createSwaggerTS from '@kubb/swagger-ts'
+import createSwaggerTanstackQuery from '@kubb/swagger-tanstack-query'
+
+export default defineConfig({
+  root: '.',
+  input: {
+    path: 'https://petstore3.swagger.io/api/v3/openapi.json',
+  },
+  output: {
+    path: './src/gen',
+    clean: true,
+  },
+  hooks: {
+    done: ['echo "🎉 done"'],
+  },
+  plugins: [createSwagger({}), createSwaggerTS({ output: { path: 'models'}, enumType: 'enum' }), createSwaggerTanstackQuery({ output: { path: './hooks' } })],
+})
+  `,
+    packages: ['@kubb/core', '@kubb/cli', '@kubb/swagger', '@kubb/swagger-ts', '@kubb/swagger-tanstack-query'],
+  },
+}
+
+export async function init({ preset = 'simple', logLevel = LogLevel.silent, packageManager = 'pnpm' }: InitProps): Promise<undefined> {
+  spinner.start('📦 Initializing Kubb')
+
+  const presetMeta = presets[preset]
+  const configPath = path.resolve(process.cwd(), './kubb.config.js')
+  const installCommand = packageManager === 'npm' ? 'install' : 'add'
+
+  spinner.start(`📀 Writing \`kubb.config.js\` ${c.dim(configPath)}`)
+  await write(presetMeta['kubb.config'], configPath)
+  spinner.succeed(`📀 Wrote \`kubb.config.js\` ${c.dim(configPath)}`)
+
+  const results = await Promise.allSettled([
+    $`npm init es6 -y`,
+    ...presetMeta.packages.map(async (pack) => {
+      spinner.start(`📀 Installing ${c.dim(pack)}`)
+      const { stdout } = await $({ preferLocal: false })`${packageManager} ${installCommand} ${pack}`
+      spinner.succeed(`📀 Installed ${c.dim(pack)}`)
+
+      return stdout
+    }),
+  ])
+
+  if (logLevel === LogLevel.info) {
+    results.forEach((result) => {
+      if (isPromiseFulfilledResult(result)) {
+        console.log(result.value)
+      }
+    })
+  }
+  spinner.succeed(`📦 initialized Kubb`)
+
+  return
+}

package/src/utils/OraWritable.ts

@@ -0,0 +1,27 @@
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+
+import { Writable } from 'node:stream'
+
+import c from 'tinyrainbow'
+
+import type { WritableOptions } from 'node:stream'
+import type { Ora } from 'ora'
+
+export class OraWritable extends Writable {
+  public command: string
+  public spinner: Ora
+  constructor(spinner: Ora, command: string, opts?: WritableOptions) {
+    super(opts)
+
+    this.command = command
+    this.spinner = spinner
+  }
+  _write(chunk: any, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+    this.spinner.suffixText = `\n\n${c.bold(c.blue(this.command))}: ${chunk?.toString()}`
+
+    callback()
+  }
+}

package/src/utils/getConfig.ts

@@ -0,0 +1,37 @@
+import { isPromise } from '@kubb/core/utils'
+
+import { getPlugins } from './getPlugins.ts'
+
+import type { CLIOptions, KubbConfig, KubbUserConfig } from '@kubb/core'
+import type { CosmiconfigResult } from './getCosmiConfig.ts'
+
+export async function getConfig(result: CosmiconfigResult, CLIOptions: CLIOptions): Promise<Array<KubbConfig> | KubbConfig> {
+  const config = result?.config
+  let kubbUserConfig = Promise.resolve(config) as Promise<KubbUserConfig | Array<KubbUserConfig>>
+
+  // for ts or js files
+  if (typeof config === 'function') {
+    const possiblePromise = config(CLIOptions)
+    if (isPromise(possiblePromise)) {
+      kubbUserConfig = possiblePromise
+    }
+    kubbUserConfig = Promise.resolve(possiblePromise)
+  }
+
+  let JSONConfig = await kubbUserConfig
+
+  if (Array.isArray(JSONConfig)) {
+    const promises = JSONConfig.map(async (item) => {
+      return { ...item, plugins: item.plugins ? await getPlugins(item.plugins) : undefined }
+    }) as unknown as Array<Promise<KubbConfig>>
+
+    return Promise.all(promises)
+  }
+
+  JSONConfig = {
+    ...JSONConfig,
+    plugins: JSONConfig.plugins ? await getPlugins(JSONConfig.plugins) : undefined,
+  }
+
+  return JSONConfig as KubbConfig
+}

package/src/utils/getCosmiConfig.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import { cosmiconfig } from 'cosmiconfig'
+import tsNode from 'ts-node'
+
+import type { defineConfig, KubbUserConfig } from '@kubb/core'
+
+export type CosmiconfigResult = {
+  filepath: string
+  isEmpty?: boolean
+  config: ReturnType<typeof defineConfig> | KubbUserConfig
+}
+
+const tsLoader = (configFile: string) => {
+  let registerer = { enabled() {} }
+
+  try {
+    // Register TypeScript compiler instance
+    registerer = tsNode.register({
+      compilerOptions: { module: 'commonjs' },
+      typeCheck: false,
+    })
+
+    const module = require(configFile)
+
+    return module.default
+  } catch (err) {
+    const error = err as Error
+
+    if (error.name === 'MODULE_NOT_FOUND') {
+      throw new Error(`'ts-node' is required for the TypeScript configuration files. Make sure it is installed\nError: ${error.message}`)
+    }
+
+    throw error
+  } finally {
+    registerer.enabled()
+  }
+}
+
+export async function getCosmiConfig(moduleName: string, config?: string): Promise<CosmiconfigResult> {
+  const searchPlaces = [
+    'package.json',
+    `.${moduleName}rc`,
+    `.${moduleName}rc.json`,
+    `.${moduleName}rc.yaml`,
+    `.${moduleName}rc.yml`,
+
+    `.${moduleName}rc.ts`,
+    `.${moduleName}rc.js`,
+    `.${moduleName}rc.mjs`,
+    `.${moduleName}rc.cjs`,
+
+    `${moduleName}.config.ts`,
+    `${moduleName}.config.js`,
+    `${moduleName}.config.mjs`,
+    `${moduleName}.config.cjs`,
+  ]
+  const explorer = cosmiconfig(moduleName, {
+    cache: false,
+    searchPlaces: [
+      ...searchPlaces.map((searchPlace) => {
+        return `.config/${searchPlace}`
+      }),
+      ...searchPlaces.map((searchPlace) => {
+        return `configs/${searchPlace}`
+      }),
+      ...searchPlaces,
+    ],
+    loaders: {
+      '.ts': tsLoader,
+    },
+  })
+
+  const result = config ? await explorer.load(config) : await explorer.search()
+
+  if (result?.isEmpty || !result || !result.config) {
+    throw new Error('Config not defined, create a kubb.config.js or pass through your config with the option --config')
+  }
+
+  return result as CosmiconfigResult
+}

package/src/utils/getPlugins.ts

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+import { PackageManager } from '@kubb/core'
+
+import type { KubbUserConfig } from '@kubb/core'
+
+function isJSONPlugins(plugins: KubbUserConfig['plugins']): plugins is Array<[name: string, options: object]> {
+  return !!(plugins as Array<[name: string, options: object]>[])?.some((plugin) => {
+    return Array.isArray(plugin) && typeof plugin?.at(0) === 'string'
+  })
+}
+
+function isObjectPlugins(plugins: KubbUserConfig['plugins']): plugins is any {
+  return plugins instanceof Object && !Array.isArray(plugins)
+}
+
+async function importPlugin(name: string, options: object): Promise<KubbUserConfig['plugins']> {
+  const packageManager = new PackageManager(process.cwd())
+
+  const importedPlugin: any = process.env.NODE_ENV === 'test' ? await import(name) : await packageManager.import(name)
+
+  // eslint-disable-next-line
+  return importedPlugin?.default ? importedPlugin.default(options) : importedPlugin(options)
+}
+
+export function getPlugins(plugins: KubbUserConfig['plugins']): Promise<KubbUserConfig['plugins']> {
+  if (isObjectPlugins(plugins)) {
+    throw new Error('Object plugins are not supported anymore, best to use http://kubb.dev/guide/configure#json')
+  }
+
+  if (isJSONPlugins(plugins)) {
+    const jsonPlugins = plugins as Array<[name: string, options: object]>
+    const promises = jsonPlugins.map((plugin) => {
+      const [name, options = {}] = plugin
+      return importPlugin(name, options)
+    })
+    return Promise.all(promises) as Promise<KubbUserConfig['plugins']>
+  }
+
+  return Promise.resolve(plugins)
+}

package/src/utils/getSummary.ts

@@ -0,0 +1,86 @@
+import path from 'node:path'
+
+import { LogLevel, randomCliColour } from '@kubb/core/logger'
+
+import c from 'tinyrainbow'
+
+import { parseHrtimeToSeconds } from './parseHrtimeToSeconds.ts'
+
+import type { KubbConfig, PluginManager } from '@kubb/core'
+import type { Logger } from '@kubb/core/logger'
+
+type SummaryProps = {
+  pluginManager: PluginManager
+  status: 'success' | 'failed'
+  hrstart: [number, number]
+  config: KubbConfig
+  logger: Logger
+}
+
+export function getSummary({ pluginManager, status, hrstart, config, logger }: SummaryProps): string[] {
+  const { logLevel } = logger
+  const logs: string[] = []
+  const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrstart))
+
+  const buildStartPlugins = pluginManager.executed
+    .filter((item) => item.hookName === 'buildStart' && item.plugin.name !== 'core')
+    .map((item) => item.plugin.name)
+
+  const buildEndPlugins = pluginManager.executed
+    .filter((item) => item.hookName === 'buildEnd' && item.plugin.name !== 'core')
+    .map((item) => item.plugin.name)
+
+  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`),
+    output: path.resolve(config.root, config.output.path),
+  } as const
+
+  if (logLevel === LogLevel.debug) {
+    logger.debug(c.bold('\nGenerated files:\n'))
+    logger.debug(files.map((file) => `${randomCliColour(JSON.stringify(file.meta?.pluginKey))} ${file.path}`).join('\n'))
+  }
+
+  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('Output:')}      ${meta.output}`, true],
+      [`\n`, true],
+    ]
+      .map((item) => {
+        if (item.at(1)) {
+          return item.at(0)
+        }
+        return undefined
+      })
+      .filter(Boolean)
+      .join('\n'),
+  )
+
+  return logs
+}

package/src/utils/parseHrtimeToSeconds.ts

@@ -0,0 +1,4 @@
+export function parseHrtimeToSeconds(hrtime: [number, number]): string {
+  const seconds = (hrtime[0] + hrtime[1] / 1e9).toFixed(3)
+  return seconds
+}

package/src/utils/renderErrors.ts

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+
+import { LogLevel } from '@kubb/core/logger'
+
+import PrettyError from 'pretty-error'
+
+export const prettyError = new PrettyError()
+  .skipPackage('commander')
+  .skip(function callback(traceLine: any) {
+    // exclude renderErrors.ts
+    const pattern = new RegExp('renderErrors')
+
+    const hasMatch = traceLine?.file?.match(pattern)
+
+    if (typeof traceLine.packageName !== 'undefined' && hasMatch) {
+      return true
+    }
+  } as PrettyError.Callback)
+  .start()
+
+function getErrorCauses(errors: Error[]): string[] {
+  return errors
+    .reduce((prev, error) => {
+      const causedError = error?.cause as Error
+      if (causedError) {
+        prev = [...prev, ...getErrorCauses([causedError])]
+      }
+      prev = [...prev, prettyError.render(error)]
+
+      return prev
+    }, [] as string[])
+    .filter(Boolean)
+}
+
+export function renderErrors(error: Error | undefined, { logLevel = LogLevel.silent }: { logLevel?: LogLevel }): string {
+  if (!error) {
+    return ''
+  }
+
+  if (logLevel === LogLevel.silent) {
+    // skip when no debug is set
+    prettyError.skipNodeFiles()
+    prettyError.skip(function skip() {
+      return true
+    } as PrettyError.Callback)
+
+    return [prettyError.render(error)].filter(Boolean).join('\n')
+  }
+
+  const errors = getErrorCauses([error])
+
+  return errors.filter(Boolean).join('\n')
+}

package/src/utils/spinner.ts

@@ -0,0 +1,5 @@
+import ora from 'ora'
+
+export const spinner = ora({
+  spinner: 'clock',
+})