@kubb/core 2.0.0-alpha.3 → 2.0.0-alpha.4

package/src/build.ts

@@ -0,0 +1,198 @@
+import pc from 'picocolors'
+
+import { clean } from './utils/clean.ts'
+import { createLogger, LogLevel } from './utils/logger.ts'
+import { randomPicoColour } from './utils/randomColour.ts'
+import { read } from './utils/read.ts'
+import { URLPath } from './utils/URLPath.ts'
+import { isInputPath } from './config.ts'
+import { FileManager } from './FileManager.ts'
+import { PluginManager } from './PluginManager.ts'
+import { isPromise } from './PromiseManager.ts'
+
+import type { KubbFile } from './FileManager.ts'
+import type { BuildOutput, KubbPlugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
+import type { Logger } from './utils/logger.ts'
+import type { QueueJob } from './utils/Queue.ts'
+
+type BuildOptions = {
+  config: PluginContext['config']
+  /**
+   * @default Logger without the spinner
+   */
+  logger?: Logger
+}
+
+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
+
+  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 ' + pc.dim(config.input.path),
+        {
+          cause: e,
+        },
+      )
+    }
+  }
+
+  if (config.output.clean) {
+    await clean(config.output.path)
+  }
+
+  const queueTask = async (file: KubbFile.File) => {
+    const { path } = file
+
+    let code: string | null = FileManager.getSource(file)
+
+    const { result: loadedResult } = await pluginManager.hookFirst({
+      hookName: 'load',
+      parameters: [path],
+    })
+    if (loadedResult && isPromise(loadedResult)) {
+      code = await loadedResult
+    }
+    if (loadedResult && !isPromise(loadedResult)) {
+      code = loadedResult
+    }
+
+    if (code) {
+      const transformedCode = await pluginManager.hookReduceArg0({
+        hookName: 'transform',
+        parameters: [code, 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
+          return pluginManager.hookForPlugin({
+            pluginKey: file.meta?.pluginKey,
+            hookName: 'writeFile',
+            parameters: [transformedCode, path],
+          })
+        }
+
+        return pluginManager.hookFirst({
+          hookName: 'writeFile',
+          parameters: [transformedCode, path],
+        })
+      }
+    }
+  }
+
+  const pluginManager = new PluginManager(config, { logger, task: queueTask as QueueJob<KubbFile.ResolvedFile>, writeTimeout: 0 })
+
+  pluginManager.on('execute', (executer) => {
+    const { hookName, parameters, plugin } = executer
+
+    if (hookName === 'writeFile' && logger.spinner) {
+      const [code] = parameters as PluginParameter<'writeFile'>
+
+      if (logger.logLevel === LogLevel.info) {
+        logger.spinner.start(`💾 Writing`)
+      }
+
+      if (logger.logLevel === 'debug') {
+        logger.info(`PluginKey ${pc.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`)
+      }
+    }
+  })
+
+  pluginManager.on('executed', (executer) => {
+    const { hookName, plugin, output, parameters } = executer
+    const messsage = `${randomPicoColour(plugin.name)} Executing ${hookName}`
+
+    if (logger.logLevel === LogLevel.info && logger.spinner) {
+      if (hookName === 'writeFile') {
+        const [_code, path] = parameters as PluginParameter<'writeFile'>
+
+        logger.spinner.suffixText = pc.dim(path)
+      } else {
+        logger.spinner.suffixText = messsage
+      }
+    }
+
+    if (logger.logLevel === LogLevel.debug) {
+      logger.info(messsage)
+      const logs = [
+        parameters && `${pc.bgWhite(`Parameters`)} ${randomPicoColour(plugin.name)} ${hookName}`,
+        JSON.stringify(parameters, undefined, 2),
+        output && `${pc.bgWhite('Output')} ${randomPicoColour(plugin.name)} ${hookName}`,
+        output,
+      ].filter(Boolean)
+
+      console.log(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<'validate', true>({
+    hookName: 'validate',
+    parameters: [pluginManager.plugins],
+  })
+
+  await pluginManager.hookParallel({
+    hookName: 'buildStart',
+    parameters: [options.config],
+  })
+
+  await pluginManager.hookParallel({ hookName: 'buildEnd' })
+
+  if (!fileManager.isExecuting && 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<'validate', true>({
+      hookName: 'validate',
+      parameters: [pluginManager.plugins],
+    })
+
+    await pluginManager.hookParallel({
+      hookName: 'buildStart',
+      parameters: [options.config],
+    })
+
+    await pluginManager.hookParallel({ hookName: 'buildEnd' })
+
+    if (!fileManager.isExecuting && 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,21 @@
+import type { CLIOptions, InputPath, KubbConfig, KubbUserConfig, PossiblePromise } 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/index.ts

@@ -0,0 +1,28 @@
+import { build } from './build.ts'
+
+import type { ObjValueTuple, TupleToUnion } from './types.ts'
+
+export { build, safeBuild } from './build.ts'
+export * from './config.ts'
+export * from './errors.ts'
+export * 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 { SchemaGenerator } from './SchemaGenerator.ts'
+export * 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/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, KubbUserPlugin, PluginContext, PluginFactoryOptions } from './types.ts'
+
+type KubbPluginFactory<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => KubbUserPlugin<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: () => KubbPlugin[]
+  plugin?: PluginContext['plugin']
+}
+
+// not publicly exported
+export type CorePluginOptions = PluginFactoryOptions<'core', 'controller', Options, false, PluginContext>
+
+export const pluginName = 'core' satisfies CorePluginOptions['name']
+export const pluginKey: CorePluginOptions['key'] = ['controller', pluginName] satisfies CorePluginOptions['key']
+
+export const definePlugin = createPlugin<CorePluginOptions>((options) => {
+  const { fileManager, pluginManager, resolvePath, resolveName, logger } = options
+
+  return {
+    name: pluginName,
+    options,
+    key: ['controller', 'core'],
+    kind: 'controller',
+    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
+    },
+  }
+})