@kubb/cli 2.0.0-alpha.3 → 2.0.0-alpha.5

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/configuration/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
+}

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/utils'
+
+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',
+})

package/src/utils/watcher.ts

@@ -0,0 +1,27 @@
+import pc from 'picocolors'
+
+import { spinner } from './spinner.ts'
+
+export async function startWatcher(path: string[], cb: (path: string[]) => Promise<void>): Promise<void> {
+  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(path)
+    } catch (e) {
+      spinner.warn(pc.red('Watcher failed'))
+    }
+  })
+
+  return
+}