@kubb/cli 1.15.0-canary.20231112T135054 → 2.0.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/cli",
-  "version": "1.15.0-canary.20231112T135054",
+  "version": "2.0.0-alpha.10",
   "description": "Generator cli",
   "keywords": [
     "typescript",
@@ -21,10 +21,18 @@
   "main": "dist/index.cjs",
   "module": "dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    }
+  },
   "bin": {
     "kubb": "bin/kubb.js"
   },
   "files": [
+    "src",
     "dist",
     "bin",
     "!/**/**.test.**",
@@ -40,15 +48,15 @@
     "pretty-error": "^4.0.0",
     "string-argv": "^0.3.2",
     "ts-node": "^10.9.1",
-    "@kubb/core": "1.15.0-canary.20231112T135011"
+    "@kubb/core": "2.0.0-alpha.10"
   },
   "devDependencies": {
-    "@types/node": "^20.8.9",
+    "@types/node": "^20.9.3",
     "source-map-support": "^0.5.21",
-    "tsup": "^7.2.0",
-    "typescript": "^5.2.2",
-    "@kubb/swagger": "1.15.0-canary.20231112T135040",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.2",
     "@kubb/ts-config": "0.1.0",
+    "@kubb/swagger": "2.0.0-alpha.10",
     "@kubb/tsup-config": "1.1.8"
   },
   "packageManager": "pnpm@8.3.0",
@@ -67,8 +75,8 @@
     "lint": "ESLINT_USE_FLAT_CONFIG=true eslint --format pretty .",
     "lint-fix": "bun run lint --quiet --fix",
     "release": "pnpm publish --no-git-check",
-    "release:canary": "bash ../../.github/canary.sh && pnpm publish --no-git-check -tag canary",
-    "release:alpha": "bash ../../.github/canary.sh && pnpm publish --no-git-check -tag alpha",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check -tag canary",
+    "release:alpha": "bash ../../.github/canary.sh && node ../../scripts/build.js alpha && pnpm publish --no-git-check -tag alpha",
     "start": "tsup --watch",
     "test": "vitest --passWithNoTests",
     "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"

package/src/generate.ts

@@ -0,0 +1,137 @@
+import { safeBuild } from '@kubb/core'
+import { createLogger, LogLevel, randomPicoColour } from '@kubb/core/utils'
+
+import { execa } from 'execa'
+import pc from 'picocolors'
+import { parseArgsStringToArgv } from 'string-argv'
+
+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' ? pc.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' ? pc.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 = randomPicoColour(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 = pc.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' ? pc.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, logLevel: CLIOptions.logLevel })
+
+  if (error) {
+    spinner.suffixText = ''
+    spinner.fail(`🚀 Build failed ${logLevel !== 'silent' ? pc.dim(inputPath) : ''}`)
+
+    console.log(summary.join(''))
+
+    throw error
+  }
+
+  await executeHooks({ hooks: config.hooks, logLevel })
+
+  spinner.suffixText = ''
+  spinner.succeed(`🚀 Build completed ${logLevel !== 'silent' ? pc.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 pc from 'picocolors'
+
+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(pc.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(${pc.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(pc.yellow(pc.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,94 @@
+import path from 'node:path'
+
+import { isPromiseFulfilledResult } from '@kubb/core/utils'
+import { LogLevel, write } from '@kubb/core/utils'
+
+import { $ } from 'execa'
+import pc from 'picocolors'
+
+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: 'models', enumType: 'enum' }), createSwaggerTanstackQuery({ output: './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\` ${pc.dim(configPath)}`)
+  await write(presetMeta['kubb.config'], configPath)
+  spinner.succeed(`📀 Wrote \`kubb.config.js\` ${pc.dim(configPath)}`)
+
+  const results = await Promise.allSettled([
+    $`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 === 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 pc from 'picocolors'
+
+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${pc.bold(pc.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.cjs`,
+    `.${moduleName}rc.mjs`,
+
+    `${moduleName}.config.ts`,
+    `${moduleName}.config.js`,
+    `${moduleName}.config.cjs`,
+    `${moduleName}.config.mjs`,
+  ]
+  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,84 @@
+import path from 'node:path'
+
+import { LogLevel, randomPicoColour } from '@kubb/core/utils'
+
+import pc from 'picocolors'
+
+import { parseHrtimeToSeconds } from './parseHrtimeToSeconds.ts'
+
+import type { KubbConfig, PluginManager } from '@kubb/core'
+
+type SummaryProps = {
+  pluginManager: PluginManager
+  status: 'success' | 'failed'
+  hrstart: [number, number]
+  config: KubbConfig
+  logLevel?: LogLevel
+}
+
+export function getSummary({ pluginManager, status, hrstart, config, logLevel }: SummaryProps): string[] {
+  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?.[1] || !b.meta?.pluginKey?.[1]) {
+      return 0
+    }
+    if (a.meta?.pluginKey?.[1]?.length < b.meta?.pluginKey?.[1]?.length) {
+      return 1
+    }
+    if (a.meta?.pluginKey?.[1]?.length > b.meta?.pluginKey?.[1]?.length) {
+      return -1
+    }
+    return 0
+  })
+
+  const meta = {
+    name: config.name,
+    plugins: status === 'success'
+      ? `${pc.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total`
+      : `${pc.red(`${failedPlugins?.length ?? 1} failed`)}, ${pluginsCount} total`,
+    pluginsFailed: status === 'failed' ? failedPlugins?.map((name) => randomPicoColour(name))?.join(', ') : undefined,
+    filesCreated: files.length,
+    time: pc.yellow(`${elapsedSeconds}s`),
+    output: path.resolve(config.root, config.output.path),
+  } as const
+
+  if (logLevel === LogLevel.debug) {
+    logs.push(pc.bold('\nGenerated files:\n'))
+    logs.push(files.map((file) => `${randomPicoColour(JSON.stringify(file.meta?.pluginKey))} ${file.path}`).join('\n'))
+  }
+
+  logs.push(
+    [
+      [`\n`, true],
+      [`     ${pc.bold('Name:')}      ${meta.name}`, !!meta.name],
+      [`  ${pc.bold('Plugins:')}      ${meta.plugins}`, true],
+      [`   ${pc.dim('Failed:')}      ${meta.pluginsFailed || 'none'}`, !!meta.pluginsFailed],
+      [`${pc.bold('Generated:')}      ${meta.filesCreated} files`, true],
+      [`     ${pc.bold('Time:')}      ${meta.time}`, true],
+      [`   ${pc.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
+}