@kubb/core 2.0.0-canary.20231030T124958 → 2.0.1

package/src/build.ts

@@ -0,0 +1,221 @@
+import c from 'tinyrainbow'
+
+import { clean } from './fs/clean.ts'
+import { read } from './fs/read.ts'
+import { URLPath } from './utils/URLPath.ts'
+import { isInputPath } from './config.ts'
+import { FileManager } from './FileManager.ts'
+import { createLogger, LogLevel, randomCliColour } from './logger.ts'
+import { PluginManager } from './PluginManager.ts'
+import { isPromise } from './PromiseManager.ts'
+
+import type { KubbFile } from './FileManager.ts'
+import type { Logger } from './logger.ts'
+import type { KubbPlugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
+
+type BuildOptions = {
+  config: PluginContext['config']
+  /**
+   * @default Logger without the spinner
+   */
+  logger?: Logger
+}
+
+type BuildOutput = {
+  files: FileManager['files']
+  pluginManager: PluginManager
+  /**
+   * Only for safeBuild
+   */
+  error?: Error
+}
+
+async function transformReducer(
+  this: PluginContext,
+  _previousCode: string,
+  result: TransformResult | Promise<TransformResult>,
+  _plugin: KubbPlugin,
+): Promise<string | null> {
+  return result
+}
+
+async function setup(options: BuildOptions): Promise<PluginManager> {
+  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options
+  let count = 0
+
+  try {
+    if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
+      await read(config.input.path)
+    }
+  } catch (e) {
+    if (isInputPath(config)) {
+      throw new Error(
+        'Cannot read file/URL defined in `input.path` or set with `kubb generate PATH` in the CLI of your Kubb config ' + c.dim(config.input.path),
+        {
+          cause: e,
+        },
+      )
+    }
+  }
+
+  if (config.output.clean) {
+    await clean(config.output.path)
+  }
+
+  const task = async (file: KubbFile.ResolvedFile): Promise<KubbFile.ResolvedFile> => {
+    const { path } = file
+
+    let source: string | null = FileManager.getSource(file)
+
+    const { result: loadedResult } = await pluginManager.hookFirst({
+      hookName: 'load',
+      parameters: [path],
+    })
+    if (loadedResult && isPromise(loadedResult)) {
+      source = await loadedResult
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
+      source = loadedResult
+    }
+
+    if (source) {
+      source = await pluginManager.hookReduceArg0({
+        hookName: 'transform',
+        parameters: [source, path],
+        reduce: transformReducer,
+      })
+
+      if (config.output.write || config.output.write === undefined) {
+        if (file.meta?.pluginKey) {
+          // run only for pluginKey defined in the meta of the file
+          await pluginManager.hookForPlugin({
+            pluginKey: file.meta?.pluginKey,
+            hookName: 'writeFile',
+            parameters: [source, path],
+          })
+        }
+
+        await pluginManager.hookFirst({
+          hookName: 'writeFile',
+          parameters: [source, path],
+        })
+      }
+    }
+
+    return {
+      ...file,
+      source: source || '',
+    }
+  }
+
+  const pluginManager = new PluginManager(config, { logger, task })
+
+  pluginManager.on('execute', (executer) => {
+    const { hookName, parameters, plugin } = executer
+
+    if (hookName === 'writeFile' && logger.spinner) {
+      const [code] = parameters as PluginParameter<'writeFile'>
+
+      if (logger.logLevel === LogLevel.debug) {
+        logger.debug(`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
+      }
+    }
+  })
+
+  pluginManager.queue.on('add', () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return
+    }
+
+    if (logger.spinner && count === 0) {
+      logger.spinner?.start(`💾 Writing`)
+    }
+  })
+
+  pluginManager.queue.on('active', () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return
+    }
+
+    if (logger.spinner && pluginManager.queue.size > 0) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
+
+      logger.spinner.suffixText = c.dim(text)
+    }
+    ;++count
+  })
+
+  pluginManager.queue.on('completed', () => {
+    if (logger.logLevel !== LogLevel.info) {
+      return
+    }
+
+    if (logger.spinner) {
+      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
+
+      logger.spinner.suffixText = c.dim(text)
+    }
+  })
+
+  pluginManager.on('executed', (executer) => {
+    const { hookName, plugin, output, parameters } = executer
+
+    if (logger.logLevel === LogLevel.debug) {
+      const logs = [
+        `${randomCliColour(plugin.name)} Executing ${hookName}`,
+        parameters && `${c.bgWhite(`Parameters`)} ${randomCliColour(plugin.name)} ${hookName}`,
+        JSON.stringify(parameters, undefined, 2),
+        output && `${c.bgWhite('Output')} ${randomCliColour(plugin.name)} ${hookName}`,
+        output,
+      ].filter(Boolean)
+
+      logger.debug(logs.join('\n'))
+    }
+  })
+
+  return pluginManager
+}
+
+export async function build(options: BuildOptions): Promise<BuildOutput> {
+  const pluginManager = await setup(options)
+
+  const { fileManager, logger } = pluginManager
+
+  await pluginManager.hookParallel({
+    hookName: 'buildStart',
+    parameters: [options.config],
+  })
+
+  await pluginManager.hookParallel({ hookName: 'buildEnd' })
+
+  if (logger.logLevel === LogLevel.info && logger.spinner) {
+    logger.spinner.suffixText = ''
+    logger.spinner.succeed(`💾 Writing completed`)
+  }
+
+  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager }
+}
+
+export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
+  const pluginManager = await setup(options)
+
+  const { fileManager, logger } = pluginManager
+
+  try {
+    await pluginManager.hookParallel({
+      hookName: 'buildStart',
+      parameters: [options.config],
+    })
+
+    await pluginManager.hookParallel({ hookName: 'buildEnd' })
+
+    if (logger.logLevel === LogLevel.info && logger.spinner) {
+      logger.spinner.suffixText = ''
+      logger.spinner.succeed(`💾 Writing completed`)
+    }
+  } catch (e) {
+    return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager, error: e as Error }
+  }
+
+  return { files: fileManager.files.map((file) => ({ ...file, source: FileManager.getSource(file) })), pluginManager }
+}

package/src/config.ts

@@ -0,0 +1,22 @@
+import type { PossiblePromise } from '@kubb/types'
+import type { CLIOptions, InputPath, KubbConfig, KubbUserConfig } from './types.ts'
+
+/**
+ * Type helper to make it easier to use kubb.config.js
+ * accepts a direct {@link KubbConfig} object, or a function that returns it.
+ * The function receives a {@link ConfigEnv} object that exposes two properties:
+ */
+export function defineConfig(
+  options:
+    | PossiblePromise<KubbUserConfig | Array<KubbUserConfig>>
+    | ((
+      /** The options derived from the CLI flags */
+      cliOptions: CLIOptions,
+    ) => PossiblePromise<KubbUserConfig | Array<KubbUserConfig>>),
+): typeof options {
+  return options
+}
+
+export function isInputPath(result: KubbConfig | undefined): result is KubbConfig<InputPath> {
+  return !!result && 'path' in (result as any)
+}

package/src/errors.ts

@@ -0,0 +1,12 @@
+/**
+ * Behaves as an Error to log a warning in the console(still stops the execution)
+ */
+export class Warning extends Error {
+  constructor(message?: string, options?: { cause: Error }) {
+    super(message, { cause: options?.cause })
+
+    this.name = 'Warning'
+  }
+}
+
+export class ValidationPluginError extends Error {}

package/src/fs/clean.ts

@@ -0,0 +1,5 @@
+import fs from 'fs-extra'
+
+export async function clean(path: string): Promise<void> {
+  return fs.remove(path)
+}

package/src/fs/index.ts

@@ -0,0 +1,3 @@
+export { clean } from './clean.ts'
+export { getRelativePath, read, readSync } from './read.ts'
+export { write } from './write.ts'

package/src/fs/read.ts

@@ -0,0 +1,68 @@
+import { basename, extname, relative } from 'node:path'
+
+import fs from 'fs-extra'
+import { switcher } from 'js-runtime'
+
+function slash(path: string, platform: 'windows' | 'mac' | 'linux' = 'linux') {
+  const isWindowsPath = /^\\\\\?\\/.test(path)
+
+  if (['linux', 'mac'].includes(platform) && !isWindowsPath) {
+    // linux and mac
+    return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
+  }
+
+  // windows
+  return path.replaceAll(/\\/g, '/').replace('../', '').trimEnd()
+}
+
+export function getRelativePath(rootDir?: string | null, filePath?: string | null, platform: 'windows' | 'mac' | 'linux' = 'linux'): string {
+  if (!rootDir || !filePath) {
+    throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ''} ${filePath || ''}`)
+  }
+
+  const relativePath = relative(rootDir, filePath)
+
+  // On Windows, paths are separated with a "\"
+  // However, web browsers use "/" no matter the platform
+  const slashedPath = slash(relativePath, platform)
+
+  if (slashedPath.startsWith('../')) {
+    return slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))
+  }
+
+  return `./${slashedPath.replace(basename(slashedPath), basename(slashedPath, extname(filePath)))}`
+}
+
+const reader = switcher(
+  {
+    node: async (path: string) => {
+      return fs.readFile(path, { encoding: 'utf8' })
+    },
+    bun: async (path: string) => {
+      const file = Bun.file(path)
+
+      return file.text()
+    },
+  },
+  'node',
+)
+
+const syncReader = switcher(
+  {
+    node: (path: string) => {
+      return fs.readFileSync(path, { encoding: 'utf8' })
+    },
+    bun: () => {
+      throw new Error('Bun cannot read sync')
+    },
+  },
+  'node',
+)
+
+export async function read(path: string): Promise<string> {
+  return reader(path)
+}
+
+export function readSync(path: string): string {
+  return syncReader(path)
+}

package/src/fs/write.ts

@@ -0,0 +1,79 @@
+import { resolve } from 'node:path'
+
+import fs from 'fs-extra'
+import { switcher } from 'js-runtime'
+
+type Options = { sanity?: boolean }
+
+const writer = switcher(
+  {
+    node: async (path: string, data: string, { sanity }: Options) => {
+      try {
+        const oldContent = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+        if (oldContent?.toString() === data?.toString()) {
+          return
+        }
+      } catch (_err) {
+        /* empty */
+      }
+
+      await fs.outputFile(resolve(path), data, { encoding: 'utf-8' })
+
+      if (sanity) {
+        const savedData = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+
+        if (savedData?.toString() !== data?.toString()) {
+          throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+        }
+
+        return savedData
+      }
+
+      return data
+    },
+    bun: async (path: string, data: string, { sanity }: Options) => {
+      try {
+        await Bun.write(resolve(path), data)
+
+        if (sanity) {
+          const file = Bun.file(resolve(path))
+          const savedData = await file.text()
+
+          if (savedData?.toString() !== data?.toString()) {
+            throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`)
+          }
+
+          return savedData
+        }
+
+        return data
+      } catch (e) {
+        console.log(e, resolve(path))
+      }
+    },
+  },
+  'node',
+)
+
+export async function write(data: string, path: string, options: Options = {}): Promise<string | undefined> {
+  if (data.trim() === '') {
+    return undefined
+  }
+  return writer(path, data.trim(), options)
+}
+
+export async function writeLog(data: string): Promise<string | undefined> {
+  if (data.trim() === '') {
+    return undefined
+  }
+  const path = resolve(process.cwd(), 'kubb-log.log')
+  let previousLogs = ''
+
+  try {
+    previousLogs = await fs.readFile(resolve(path), { encoding: 'utf-8' })
+  } catch (_err) {
+    /* empty */
+  }
+
+  return writer(path, [previousLogs, data.trim()].filter(Boolean).join('\n\n\n'), { sanity: false })
+}

package/src/index.ts

@@ -0,0 +1,27 @@
+import { build } from './build.ts'
+
+import type { ObjValueTuple, TupleToUnion } from '@kubb/types'
+
+export { build, safeBuild } from './build.ts'
+export { defineConfig, isInputPath } from './config.ts'
+export { Warning } from './errors.ts'
+export { FileManager, KubbFile } from './FileManager.ts'
+export { Generator } from './Generator.ts'
+export { PackageManager } from './PackageManager.ts'
+// dprint-ignore
+export { createPlugin, pluginName as name, pluginName } from './plugin.ts'
+export { PluginManager } from './PluginManager.ts'
+export { PromiseManager } from './PromiseManager.ts'
+export type * from './types.ts'
+
+export interface _Register {}
+export type Plugins = _Register
+export type OptionsPlugins = { [K in keyof Plugins]: Plugins[K]['options'] }
+
+export type OptionsOfPlugin<K extends keyof Plugins> = Plugins[K]['options']
+
+export type PluginUnion = TupleToUnion<ObjValueTuple<OptionsPlugins>>
+
+export type Plugin = keyof Plugins
+
+export default build

package/src/logger.ts

@@ -0,0 +1,121 @@
+import seedrandom from 'seedrandom'
+import c, { createColors } from 'tinyrainbow'
+
+import { writeLog } from './fs/write.ts'
+
+import type { Ora } from 'ora'
+import type { Formatter } from 'tinyrainbow'
+
+export const LogLevel = {
+  silent: 'silent',
+  info: 'info',
+  debug: 'debug',
+} as const
+
+export type LogLevel = keyof typeof LogLevel
+
+export type Logger = {
+  /**
+   * Optional config name to show in CLI output
+   */
+  name?: string
+  logLevel: LogLevel
+  log: (message: string | null) => void
+  error: (message: string | null) => void
+  info: (message: string | null) => void
+  warn: (message: string | null) => void
+  debug: (message: string | null) => Promise<void>
+  spinner?: Ora
+  logs: string[]
+}
+
+type Props = {
+  name?: string
+  logLevel: LogLevel
+  spinner?: Ora
+}
+
+export function createLogger({ logLevel, name, spinner }: Props): Logger {
+  const logs: string[] = []
+  const log: Logger['log'] = (message) => {
+    if (message && spinner) {
+      spinner.text = message
+      logs.push(message)
+    }
+  }
+
+  const error: Logger['error'] = (message) => {
+    if (message) {
+      throw new Error(message || 'Something went wrong')
+    }
+  }
+
+  const warn: Logger['warn'] = (message) => {
+    if (message && spinner) {
+      spinner.warn(c.yellow(message))
+      logs.push(message)
+    }
+  }
+
+  const info: Logger['warn'] = (message) => {
+    if (message && spinner && logLevel !== LogLevel.silent) {
+      spinner.info(message)
+      logs.push(message)
+    }
+  }
+
+  const debug: Logger['debug'] = async (message) => {
+    if (message) {
+      await writeLog(message)
+    }
+  }
+
+  const logger: Logger = {
+    name,
+    logLevel,
+    log,
+    error,
+    warn,
+    info,
+    debug,
+    spinner,
+    logs,
+  }
+
+  return logger
+}
+
+const defaultColours = ['black', 'blue', 'darkBlue', 'cyan', 'gray', 'green', 'darkGreen', 'magenta', 'red', 'darkRed', 'yellow', 'darkYellow'] as const
+
+export function randomColour(text?: string, colours = defaultColours): string {
+  if (!text) {
+    return 'white'
+  }
+
+  const random = seedrandom(text)
+  const colour = colours.at(Math.floor(random() * colours.length)) || 'white'
+
+  return colour
+}
+
+export function randomCliColour(text?: string, colors = defaultColours): string {
+  const colours = createColors(true)
+
+  if (!text) {
+    return colours.white(text)
+  }
+
+  const colour = randomColour(text, colors)
+  const isDark = colour.includes('dark')
+  const key = colour.replace('dark', '').toLowerCase() as keyof typeof colours
+  const formatter: Formatter = colours[key] as Formatter
+
+  if (isDark) {
+    return c.bold(formatter(text))
+  }
+
+  if (typeof formatter !== 'function') {
+    throw new Error('Formatter for picoColor is not of type function/Formatter')
+  }
+  return formatter(text)
+}

package/src/plugin.ts

@@ -0,0 +1,80 @@
+import path from 'node:path'
+
+import { createPluginCache } from './utils/cache.ts'
+
+import type { FileManager } from './FileManager.ts'
+import type { PluginManager } from './PluginManager.ts'
+import type { KubbPlugin, KubbUserPluginWithLifeCycle, PluginContext, PluginFactoryOptions } from './types.ts'
+
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => KubbUserPluginWithLifeCycle<T>
+
+export function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(factory: KubbPluginFactory<T>) {
+  return (options: T['options']): ReturnType<KubbPluginFactory<T>> => {
+    return factory(options)
+  }
+}
+
+type Options = {
+  config: PluginContext['config']
+  fileManager: FileManager
+  pluginManager: PluginManager
+  resolvePath: PluginContext['resolvePath']
+  resolveName: PluginContext['resolveName']
+  logger: PluginContext['logger']
+  getPlugins: () => Array<KubbPlugin>
+  plugin?: PluginContext['plugin']
+}
+
+// not publicly exported
+export type CorePluginOptions = PluginFactoryOptions<'core', Options, Options, PluginContext, never>
+
+export const pluginName = 'core' satisfies CorePluginOptions['name']
+export const pluginKey: CorePluginOptions['key'] = [pluginName] satisfies CorePluginOptions['key']
+
+export const definePlugin = createPlugin<CorePluginOptions>((options) => {
+  const { fileManager, pluginManager, resolvePath, resolveName, logger } = options
+
+  return {
+    name: pluginName,
+    options,
+    key: ['core'],
+
+    api() {
+      return {
+        get config() {
+          return options.config
+        },
+        get plugins() {
+          return options.getPlugins()
+        },
+        get plugin() {
+          // see pluginManger.#execute where we override with `.call` the this with the correct plugin
+          return options.plugin as NonNullable<Options['plugin']>
+        },
+        logger,
+        fileManager,
+        pluginManager,
+        async addFile(...files) {
+          const resolvedFiles = await fileManager.add(...files)
+
+          if (!Array.isArray(resolvedFiles)) {
+            return [resolvedFiles]
+          }
+
+          return resolvedFiles
+        },
+        resolvePath,
+        resolveName,
+        cache: createPluginCache(),
+      }
+    },
+    resolvePath(baseName) {
+      const root = path.resolve(this.config.root, this.config.output.path)
+
+      return path.resolve(root, baseName)
+    },
+    resolveName(name) {
+      return name
+    },
+  }
+})

package/src/transformers/casing.ts

@@ -0,0 +1,9 @@
+import { camelCase as changeCaseCamel, pascalCase as changePascalCase } from 'change-case'
+
+export function camelCase(text: string): string {
+  return changeCaseCamel(text, { delimiter: '', mergeAmbiguousCharacters: true })
+}
+
+export function pascalCase(text: string): string {
+  return changePascalCase(text, { delimiter: '', mergeAmbiguousCharacters: true })
+}

package/src/transformers/combineCodes.ts

@@ -0,0 +1,3 @@
+export function combineCodes(codes: string[]): string {
+  return codes.join('\n')
+}

package/src/transformers/createJSDocBlockText.ts

@@ -0,0 +1,9 @@
+export function createJSDocBlockText({ comments }: { comments: Array<string> }): string {
+  const filteredComments = comments.filter(Boolean)
+
+  if (!filteredComments.length) {
+    return ''
+  }
+
+  return `/**\n * ${filteredComments.join('\n * ')}\n */`
+}