@kubb/cli 1.1.11 → 1.1.13

package/src/init.ts

@@ -1,91 +0,0 @@
-import pathParser from 'node:path'
-
-import { write } from '@kubb/core'
-
-import { $ } from 'execa'
-import pc from 'picocolors'
-
-import type { LogLevel } from '@kubb/core'
-import type { Ora } from 'ora'
-
-export type Preset = 'simple'
-
-export type PackageManager = 'pnpm' | 'npm' | 'yarn'
-
-export type PresetMeta = {
-  'kubb.config': string
-  packages: string[]
-}
-
-type RunProps = {
-  spinner: Ora
-  /**
-   * @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"',
-  },
-  logLevel: 'info',
-  plugins: [createSwagger({}), createSwaggerTS({ output: 'models', enumType: 'enum' }), createSwaggerTanstackQuery({ output: './hooks' })],
-})
-  `,
-    packages: ['@kubb/core', '@kubb/cli', '@kubb/swagger', '@kubb/swagger-ts', '@kubb/swagger-tanstack-query'],
-  },
-}
-
-export async function init({ spinner, preset = 'simple', logLevel = 'silent', packageManager = 'pnpm' }: RunProps): Promise<void> {
-  try {
-    const presetMeta = presets[preset]
-    const path = pathParser.resolve(process.cwd(), './kubb.config.js')
-    const installCommand = packageManager === 'npm' ? 'install' : 'add'
-
-    spinner.start(`📀 Writing \`kubb.config.js\` ${pc.dim(path)}`)
-    await write(presetMeta['kubb.config'], path)
-    spinner.succeed(`📀 Wrote \`kubb.config.js\` ${pc.dim(path)}`)
-
-    const data = await Promise.all([
-      $`npm init es6 -y`,
-      ...presetMeta.packages.map(async (pack) => {
-        spinner.start(`📀 Installing ${pc.dim(pack)}`)
-        const { stdout } = await $({ preferLocal: false })`${packageManager} ${installCommand} ${pack}`
-        spinner.succeed(`📀 Installed ${pc.dim(pack)}`)
-
-        return stdout
-      }),
-    ])
-
-    if (logLevel === 'info') {
-      data.forEach((text) => console.log(text))
-    }
-  } catch (error) {
-    spinner.fail(pc.red(`Something went wrong\n\n${(error as Error)?.message}`))
-  }
-}

package/src/run.ts

@@ -1,179 +0,0 @@
-import pathParser from 'node:path'
-
-import { build, throttle, ParallelPluginError, PluginError } from '@kubb/core'
-
-import { execa } from 'execa'
-import pc from 'picocolors'
-import PrettyError from 'pretty-error'
-import { parseArgsStringToArgv } from 'string-argv'
-
-import { parseHrtimeToSeconds } from './utils/parseHrtimeToSeconds.ts'
-import { parseText } from './utils/parseText.ts'
-
-import type { BuildOutput, CLIOptions, KubbConfig, Logger, LogLevel } from '@kubb/core'
-import type { Ora } from 'ora'
-import { OraWritable } from './utils/OraWritable.ts'
-
-type RunProps = {
-  config: KubbConfig
-  spinner: Ora
-  options: CLIOptions
-}
-
-export async function run({ config, options, spinner }: RunProps): Promise<void> {
-  const hrstart = process.hrtime()
-  const [log] = throttle<void, Parameters<Logger['log']>>((message, { logLevel, params }) => {
-    if (logLevel === 'error') {
-      spinner.fail(pc.red(`${message}\n\n` || `Something went wrong\n\n`))
-    } else if (logLevel === 'info') {
-      if (message) {
-        spinner.text = message
-      } else {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        spinner.text = `🪂 Executing ${params?.hookName || 'unknown'}(${pc.yellow(params?.pluginName || 'unknown')})`
-      }
-    }
-  }, 100)
-  const logger: Logger = {
-    log,
-    spinner,
-  }
-
-  const onDone = async (hooks: KubbConfig['hooks'], logLevel: LogLevel) => {
-    if (!hooks?.done) {
-      return
-    }
-
-    let commands: string[] = []
-    if (typeof hooks?.done === 'string') {
-      commands = [hooks.done]
-    } else {
-      commands = hooks.done
-    }
-
-    const promises = commands.map(async (command) => {
-      const oraWritable = new OraWritable(spinner, command)
-      const [cmd, ..._args] = [...parseArgsStringToArgv(command)]
-      spinner.start(parseText(`🪂 Executing hooks(${pc.yellow('done')})`, { info: ` ${pc.dim(command)}` }, logLevel))
-
-      const { stdout } = await execa(cmd, _args, {}).pipeStdout!(oraWritable)
-      spinner.suffixText = ''
-      oraWritable.destroy()
-
-      if (logLevel === 'info') {
-        spinner.succeed(parseText(`🪂 Executing hooks(${pc.yellow('done')})`, { info: ` ${pc.dim(command)}` }, logLevel))
-
-        console.log(stdout)
-      }
-    })
-
-    await Promise.all(promises)
-
-    if (logLevel === 'silent') {
-      spinner.succeed(parseText(`🪂 Executing hooks(${pc.yellow('done')})`, {}, logLevel))
-    }
-  }
-
-  const printSummary = (pluginManager: BuildOutput['pluginManager'], status: 'success' | 'failed') => {
-    const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrstart))
-
-    const buildStartPlugins = [
-      ...new Set(pluginManager.executed.filter((item) => item.hookName === 'buildStart' && item.plugin.name !== 'core').map((item) => item.plugin.name)),
-    ]
-    const pluginsCount = config.plugins?.length || 0
-    const files = pluginManager.fileManager.files.sort((a, b) => {
-      if (!a.meta?.pluginName || !b.meta?.pluginName) {
-        return 0
-      }
-      if (a.meta?.pluginName.length < b.meta?.pluginName.length) {
-        return 1
-      }
-      if (a.meta?.pluginName.length > b.meta?.pluginName.length) {
-        return -1
-      }
-      return 0
-    })
-
-    const meta = {
-      plugins:
-        status === 'success'
-          ? `${pc.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total`
-          : `${pc.red(`${pluginsCount - buildStartPlugins.length} failed`)}, ${pluginsCount} total`,
-      filesCreated: files.length,
-      time: pc.yellow(`${elapsedSeconds}s`),
-      output: pathParser.resolve(config.root, config.output.path),
-    } as const
-
-    console.log(`
-  ${pc.bold('Plugins:')}      ${meta.plugins}
-${pc.bold('Generated:')}      ${meta.filesCreated} files
-     ${pc.bold('Time:')}      ${meta.time}
-   ${pc.bold('Output:')}      ${meta.output}
-     `)
-
-    if (options.debug) {
-      console.log(`${pc.bold('Generated files:')}`)
-      console.log(`${files.map((file) => `${pc.blue(file.meta?.pluginName)} ${file.path}`).join('\n')}`)
-    }
-  }
-
-  const printErrors = (error: Error) => {
-    const pe = new PrettyError()
-
-    if (options.debug) {
-      spinner.fail(pc.red(`Something went wrong\n\n`))
-      const causedError = error?.cause as Error
-
-      console.log(pe.render(error))
-
-      if (causedError) {
-        console.log(pe.render(causedError))
-      }
-    } else {
-      spinner.fail(pc.red(`Something went wrong\n\n${error?.message}`))
-    }
-  }
-
-  try {
-    const { root, ...userConfig } = config
-    const logLevel = options.logLevel ?? userConfig.logLevel ?? 'silent'
-    const inputPath = options.input ?? userConfig.input.path
-
-    spinner.start(parseText(`🚀 Building`, { info: `(${pc.dim(inputPath)})` }, logLevel))
-
-    const output = await build({
-      config: {
-        root: process.cwd(),
-        ...userConfig,
-        logLevel,
-        input: {
-          ...userConfig.input,
-          path: inputPath,
-        },
-        output: {
-          write: true,
-          ...userConfig.output,
-        },
-      },
-      logger,
-    })
-
-    spinner.succeed(parseText(`🚀 Build completed`, { info: `(${pc.dim(inputPath)})` }, logLevel))
-
-    await onDone(config.hooks, logLevel)
-
-    printSummary(output.pluginManager, 'success')
-  } catch (error: any) {
-    if (error instanceof ParallelPluginError) {
-      error.errors.map((e) => printErrors(e))
-    } else {
-      printErrors(error as Error)
-    }
-
-    if (error instanceof PluginError || error instanceof ParallelPluginError) {
-      printSummary(error.pluginManager, 'failed')
-    }
-
-    throw error
-  }
-}

package/src/types.ts

@@ -1,7 +0,0 @@
-import type { defineConfig, KubbUserConfig } from '@kubb/core'
-
-export type CosmiconfigResult = {
-  filepath: string
-  isEmpty?: boolean
-  config: ReturnType<typeof defineConfig> | KubbUserConfig
-}

package/src/utils/OraWritable.ts

@@ -1,20 +0,0 @@
-import type { WritableOptions } from 'node:stream'
-import { Writable } from 'node:stream'
-import type { Ora } from 'ora'
-import pc from 'picocolors'
-
-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: NodeJS.BufferEncoding, callback: (error?: Error | null) => void) {
-    this.spinner.suffixText = `\n\n${pc.bold(pc.blue(this.command))}: ${chunk?.toString()}`
-
-    callback()
-  }
-}

package/src/utils/getConfig.ts

@@ -1,28 +0,0 @@
-import { isPromise } from '@kubb/core'
-
-import { getPlugins } from './getPlugins.ts'
-
-import type { CLIOptions, KubbConfig, KubbUserConfig } from '@kubb/core'
-import type { CosmiconfigResult } from '../types.ts'
-
-export async function getConfig(result: CosmiconfigResult, options: CLIOptions): Promise<KubbConfig> {
-  const config = result?.config
-  let kubbUserConfig: Promise<KubbUserConfig> = Promise.resolve(config) as Promise<KubbUserConfig>
-
-  // for ts or js files
-  if (typeof config === 'function') {
-    const possiblePromise = config(options)
-    if (isPromise(possiblePromise)) {
-      kubbUserConfig = possiblePromise
-    }
-    kubbUserConfig = Promise.resolve(possiblePromise)
-  }
-
-  let JSONConfig = await kubbUserConfig
-  JSONConfig = {
-    ...JSONConfig,
-    plugins: JSONConfig.plugins ? await getPlugins(JSONConfig.plugins) : undefined,
-  }
-
-  return JSONConfig as KubbConfig
-}

package/src/utils/getCosmiConfig.ts

@@ -1,80 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-import { cosmiconfig } from 'cosmiconfig'
-import tsNode from 'ts-node'
-import yaml from 'yaml'
-
-import { importModule } from './importModule.ts'
-
-import type { CosmiconfigResult } from '../types.ts'
-
-const jsLoader = async (configFile: string) => {
-  return importModule(configFile)
-}
-// TODO fix tsLoader for node 20
-// https://github.com/TypeStrong/ts-node/issues/1997
-const tsLoader = (configFile: string) => {
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
-  let registerer = { enabled() {} }
-
-  try {
-    // Register TypeScript compiler instance
-    registerer = tsNode.register({
-      compilerOptions: { module: 'commonjs' },
-      swc: true,
-      typeCheck: false,
-    })
-
-    const module = require(configFile)
-
-    return module.default
-  } catch (err: any) {
-    if (err.code === 'MODULE_NOT_FOUND') {
-      throw new Error(`'ts-node' is required for the TypeScript configuration files. Make sure it is installed\nError: ${err.message}`)
-    }
-    console.log(err)
-
-    throw err
-  } finally {
-    registerer.enabled()
-  }
-}
-
-export async function getCosmiConfig(moduleName: string, config?: string) {
-  const explorer = cosmiconfig(moduleName, {
-    cache: false,
-    searchPlaces: [
-      'package.json',
-      `.${moduleName}rc`,
-      `.${moduleName}rc.json`,
-      `.${moduleName}rc.yaml`,
-      `.${moduleName}rc.yml`,
-      // TODO fix tsLoader
-      `.${moduleName}rc.ts`,
-      `.${moduleName}rc.js`,
-      `.${moduleName}rc.cjs`,
-      `.${moduleName}rc.mjs`,
-      // TODO fix tsLoader
-      `${moduleName}.config.ts`,
-      `${moduleName}.config.js`,
-      `${moduleName}.config.cjs`,
-      `${moduleName}.config.mjs`,
-    ],
-    loaders: {
-      '.yaml': (filepath, content) => yaml.parse(content),
-      '.yml': (filepath, content) => yaml.parse(content),
-      '.js': jsLoader,
-      '.cjs': jsLoader,
-      '.mjs': jsLoader,
-      '.ts': tsLoader,
-      noExt: jsLoader,
-    },
-  })
-
-  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

@@ -1,40 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-nocheck
-
-import { importModule } from './importModule.ts'
-
-import type { KubbJSONPlugin, KubbObjectPlugin, KubbUserConfig } from '@kubb/core'
-
-function isJSONPlugins(plugins: KubbUserConfig['plugins'] | KubbJSONPlugin[]): plugins is KubbJSONPlugin[] {
-  return !!(plugins as KubbJSONPlugin[])?.some((plugin) => {
-    return typeof plugin?.[0] === 'string'
-  })
-}
-
-function isObjectPlugins(plugins: KubbUserConfig['plugins'] | KubbJSONPlugin[]): plugins is KubbObjectPlugin {
-  return plugins instanceof Object && !Array.isArray(plugins)
-}
-
-async function importPlugin(name: string, options: object) {
-  const importedPlugin = process.env.NODE_ENV === 'test' ? await import(name) : await importModule(name, process.cwd())
-
-  return importedPlugin?.default ? importedPlugin.default(options) : importedPlugin(options)
-}
-
-export function getPlugins(plugins: KubbUserConfig['plugins'] | KubbJSONPlugin[]): Promise<KubbUserConfig['plugins']> {
-  if (isObjectPlugins(plugins)) {
-    const promises = Object.keys(plugins).map(async (name) => {
-      return importPlugin(name, plugins[name as keyof typeof plugins])
-    })
-    return Promise.all(promises)
-  }
-
-  if (isJSONPlugins(plugins)) {
-    const promises = plugins.map(async (plugin) => {
-      const [name, options = {}] = plugin
-      return importPlugin(name, options)
-    })
-    return Promise.all(promises)
-  }
-  return Promise.resolve(plugins)
-}

package/src/utils/importModule.ts

@@ -1,36 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-import mod from 'node:module'
-import { pathToFileURL } from 'node:url'
-
-const SLASHES = new Set(['/', '\\'])
-
-/**
- * Normalizes directories to have a trailing slash.
- * Resolve is pretty finicky -- if the directory name doesn't have
- * a trailing slash then it tries to look in the parent directory.
- * i.e., if the directory is "/usr/nzakas/foo" it will start the
- * search in /usr/nzakas. However, if the directory is "/user/nzakas/foo/",
- * then it will start the search in /user/nzakas/foo.
- * @param {string} directory The directory to check.
- * @returns {string} The normalized directory.
- */
-export function normalizeDirectory(directory: string) {
-  if (!SLASHES.has(directory[directory.length - 1])) {
-    return `${directory}/`
-  }
-
-  return directory
-}
-
-export async function importModule(path: string, cwd?: string): Promise<any> {
-  let location = path
-
-  if (cwd) {
-    const require = mod.createRequire(normalizeDirectory(cwd))
-    location = require.resolve(path)
-  }
-
-  const module = await import(pathToFileURL(location).href)
-
-  return module?.default ?? module
-}

package/src/utils/index.ts

@@ -1,8 +0,0 @@
-export * from './getConfig.ts'
-export * from './getPlugins.ts'
-export * from './watcher.ts'
-export * from './getCosmiConfig.ts'
-export * from './importModule.ts'
-export * from './parseHrtimeToSeconds.ts'
-export * from './parseText.ts'
-export * from './OraWritable.ts'

package/src/utils/mocks/noop.cjs

@@ -1,3 +0,0 @@
-module.exports = function noop() {
-  return 'cjs-noop'
-}

package/src/utils/mocks/noop.js

@@ -1,3 +0,0 @@
-export function noop() {
-  return 'js-noop'
-}

package/src/utils/parseHrtimeToSeconds.ts

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

package/src/utils/parseText.ts

@@ -1,5 +0,0 @@
-import type { LogLevel } from '@kubb/core'
-
-export function parseText(baseText: string, config: Partial<Record<LogLevel, string>>, logLevel: LogLevel = 'silent') {
-  return `${baseText}${config[logLevel] || ''}`
-}

package/src/utils/watcher.ts

@@ -1,30 +0,0 @@
-import pc from 'picocolors'
-
-import type { Ora } from 'ora'
-
-type Options = {
-  path: string[]
-  spinner: Ora
-}
-export async function startWatcher(cb: (path: string[]) => Promise<void>, options: Options) {
-  const { spinner, path } = options
-  const { watch } = await import('chokidar')
-
-  const ignored = ['**/{.git,node_modules}/**']
-
-  const watcher = watch(path, {
-    ignorePermissionErrors: true,
-    ignored,
-  })
-  watcher.on('all', (type, file) => {
-    spinner.succeed(pc.yellow(pc.bold(`Change detected: ${type} ${file}`)))
-    // revert back
-    spinner.spinner = 'clock'
-
-    try {
-      cb(options.path)
-    } catch (e) {
-      spinner.warn(pc.red('Watcher failed'))
-    }
-  })
-}