@kubb/core 5.0.0-alpha.9 → 5.0.0-beta.2

package/src/build.ts

@@ -1,418 +0,0 @@
-import { dirname, relative, resolve } from 'node:path'
-import { AsyncEventEmitter, BuildError, exists, formatMs, getElapsedMs, getRelativePath, URLPath } from '@internals/utils'
-import type { Fabric as FabricType, KubbFile } from '@kubb/fabric-core/types'
-import { createFabric } from '@kubb/react-fabric'
-import { typescriptParser } from '@kubb/react-fabric/parsers'
-import { fsPlugin } from '@kubb/react-fabric/plugins'
-import { isInputPath } from './config.ts'
-import { BARREL_FILENAME, DEFAULT_BANNER, DEFAULT_CONCURRENCY, DEFAULT_EXTENSION, DEFAULT_STUDIO_URL } from './constants.ts'
-import { PluginDriver } from './PluginDriver.ts'
-import { fsStorage } from './storages/fsStorage.ts'
-import type { AdapterSource, Config, KubbEvents, Output, Plugin, Storage, UserConfig } from './types.ts'
-import { getDiagnosticInfo } from './utils/diagnostics.ts'
-import type { FileMetaBase } from './utils/getBarrelFiles.ts'
-
-type BuildOptions = {
-  config: UserConfig
-  events?: AsyncEventEmitter<KubbEvents>
-}
-
-type BuildOutput = {
-  failedPlugins: Set<{ plugin: Plugin; error: Error }>
-  fabric: FabricType
-  files: Array<KubbFile.ResolvedFile>
-  driver: PluginDriver
-  pluginTimings: Map<string, number>
-  error?: Error
-  sources: Map<KubbFile.Path, string>
-}
-
-type SetupResult = {
-  events: AsyncEventEmitter<KubbEvents>
-  fabric: FabricType
-  driver: PluginDriver
-  sources: Map<KubbFile.Path, string>
-}
-
-export async function setup(options: BuildOptions): Promise<SetupResult> {
-  const { config: userConfig, events = new AsyncEventEmitter<KubbEvents>() } = options
-
-  const sources: Map<KubbFile.Path, string> = new Map<KubbFile.Path, string>()
-  const diagnosticInfo = getDiagnosticInfo()
-
-  if (Array.isArray(userConfig.input)) {
-    await events.emit('warn', 'This feature is still under development — use with caution')
-  }
-
-  await events.emit('debug', {
-    date: new Date(),
-    logs: [
-      'Configuration:',
-      `  • Name: ${userConfig.name || 'unnamed'}`,
-      `  • Root: ${userConfig.root || process.cwd()}`,
-      `  • Output: ${userConfig.output?.path || 'not specified'}`,
-      `  • Plugins: ${userConfig.plugins?.length || 0}`,
-      'Output Settings:',
-      `  • Storage: ${userConfig.output?.storage ? `custom(${userConfig.output.storage.name})` : userConfig.output?.write === false ? 'disabled' : 'filesystem (default)'}`,
-      `  • Formatter: ${userConfig.output?.format || 'none'}`,
-      `  • Linter: ${userConfig.output?.lint || 'none'}`,
-      'Environment:',
-      Object.entries(diagnosticInfo)
-        .map(([key, value]) => `  • ${key}: ${value}`)
-        .join('\n'),
-    ],
-  })
-
-  try {
-    if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
-      await exists(userConfig.input.path)
-
-      await events.emit('debug', {
-        date: new Date(),
-        logs: [`✓ Input file validated: ${userConfig.input.path}`],
-      })
-    }
-  } catch (caughtError) {
-    if (isInputPath(userConfig)) {
-      const error = caughtError as Error
-
-      throw new Error(
-        `Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${userConfig.input.path}`,
-        {
-          cause: error,
-        },
-      )
-    }
-  }
-
-  const definedConfig: Config = {
-    root: userConfig.root || process.cwd(),
-    ...userConfig,
-    output: {
-      write: true,
-      barrelType: 'named',
-      extension: DEFAULT_EXTENSION,
-      defaultBanner: DEFAULT_BANNER,
-      ...userConfig.output,
-    },
-    devtools: userConfig.devtools
-      ? {
-          studioUrl: DEFAULT_STUDIO_URL,
-          ...(typeof userConfig.devtools === 'boolean' ? {} : userConfig.devtools),
-        }
-      : undefined,
-    plugins: userConfig.plugins as Config['plugins'],
-  }
-
-  // write: false is the explicit dry-run opt-out; otherwise use the provided
-  // storage or fall back to fsStorage (backwards-compatible default).
-  // Keys are root-relative (e.g. `src/gen/api/getPets.ts`) so fsStorage()
-  // needs no configuration — it resolves them against process.cwd().
-  const storage: Storage | null = definedConfig.output.write === false ? null : (definedConfig.output.storage ?? fsStorage())
-
-  if (definedConfig.output.clean) {
-    await events.emit('debug', {
-      date: new Date(),
-      logs: ['Cleaning output directories', `  • Output: ${definedConfig.output.path}`],
-    })
-    await storage?.clear(resolve(definedConfig.root, definedConfig.output.path))
-  }
-
-  const fabric = createFabric()
-  fabric.use(fsPlugin)
-  fabric.use(typescriptParser)
-
-  fabric.context.on('files:processing:start', (files) => {
-    events.emit('files:processing:start', files)
-    events.emit('debug', {
-      date: new Date(),
-      logs: [`Writing ${files.length} files...`],
-    })
-  })
-
-  fabric.context.on('file:processing:update', async (params) => {
-    const { file, source } = params
-    await events.emit('file:processing:update', {
-      ...params,
-      config: definedConfig,
-      source,
-    })
-
-    if (source) {
-      // Key is root-relative so it's meaningful for any backend (fs, S3, Redis…)
-      const key = relative(resolve(definedConfig.root), file.path)
-      await storage?.setItem(key, source)
-      sources.set(file.path, source)
-    }
-  })
-
-  fabric.context.on('files:processing:end', async (files) => {
-    await events.emit('files:processing:end', files)
-    await events.emit('debug', {
-      date: new Date(),
-      logs: [`✓ File write process completed for ${files.length} files`],
-    })
-  })
-
-  await events.emit('debug', {
-    date: new Date(),
-    logs: [
-      '✓ Fabric initialized',
-      `  • Storage: ${storage ? storage.name : 'disabled (dry-run)'}`,
-      `  • Barrel type: ${definedConfig.output.barrelType || 'none'}`,
-    ],
-  })
-
-  const pluginDriver = new PluginDriver(definedConfig, {
-    fabric,
-    events,
-    concurrency: DEFAULT_CONCURRENCY,
-  })
-
-  // Run the adapter (if provided) to produce the universal RootNode
-  if (definedConfig.adapter) {
-    const source = inputToAdapterSource(definedConfig)
-
-    await events.emit('debug', {
-      date: new Date(),
-      logs: [`Running adapter: ${definedConfig.adapter.name}`],
-    })
-
-    pluginDriver.adapter = definedConfig.adapter
-    pluginDriver.rootNode = await definedConfig.adapter.parse(source)
-
-    await events.emit('debug', {
-      date: new Date(),
-      logs: [
-        `✓ Adapter '${definedConfig.adapter.name}' resolved RootNode`,
-        `  • Schemas: ${pluginDriver.rootNode.schemas.length}`,
-        `  • Operations: ${pluginDriver.rootNode.operations.length}`,
-      ],
-    })
-  }
-
-  return {
-    events,
-    fabric,
-    driver: pluginDriver,
-    sources,
-  }
-}
-
-export async function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  const { fabric, files, driver, failedPlugins, pluginTimings, error, sources } = await safeBuild(options, overrides)
-
-  if (error) {
-    throw error
-  }
-
-  if (failedPlugins.size > 0) {
-    const errors = [...failedPlugins].map(({ error }) => error)
-
-    throw new BuildError(`Build Error with ${failedPlugins.size} failed plugins`, { errors })
-  }
-
-  return {
-    failedPlugins,
-    fabric,
-    files,
-    driver,
-    pluginTimings,
-    error: undefined,
-    sources,
-  }
-}
-
-export async function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput> {
-  const { fabric, driver, events, sources } = overrides ? overrides : await setup(options)
-
-  const failedPlugins = new Set<{ plugin: Plugin; error: Error }>()
-  // in ms
-  const pluginTimings = new Map<string, number>()
-  const config = driver.config
-
-  try {
-    for (const plugin of driver.plugins) {
-      const context = driver.getContext(plugin)
-      const hrStart = process.hrtime()
-
-      const installer = plugin.install.bind(context)
-
-      try {
-        const timestamp = new Date()
-
-        await events.emit('plugin:start', plugin)
-
-        await events.emit('debug', {
-          date: timestamp,
-          logs: ['Installing plugin...', `  • Plugin Name: ${plugin.name}`],
-        })
-
-        await installer(context)
-
-        const duration = getElapsedMs(hrStart)
-        pluginTimings.set(plugin.name, duration)
-
-        await events.emit('plugin:end', plugin, { duration, success: true })
-
-        await events.emit('debug', {
-          date: new Date(),
-          logs: [`✓ Plugin installed successfully (${formatMs(duration)})`],
-        })
-      } catch (caughtError) {
-        const error = caughtError as Error
-        const errorTimestamp = new Date()
-        const duration = getElapsedMs(hrStart)
-
-        await events.emit('plugin:end', plugin, {
-          duration,
-          success: false,
-          error,
-        })
-
-        await events.emit('debug', {
-          date: errorTimestamp,
-          logs: [
-            '✗ Plugin installation failed',
-            `  • Plugin Name: ${plugin.name}`,
-            `  • Error: ${error.constructor.name} - ${error.message}`,
-            '  • Stack Trace:',
-            error.stack || 'No stack trace available',
-          ],
-        })
-
-        failedPlugins.add({ plugin, error })
-      }
-    }
-
-    if (config.output.barrelType) {
-      const root = resolve(config.root)
-      const rootPath = resolve(root, config.output.path, BARREL_FILENAME)
-      const rootDir = dirname(rootPath)
-
-      await events.emit('debug', {
-        date: new Date(),
-        logs: ['Generating barrel file', `  • Type: ${config.output.barrelType}`, `  • Path: ${rootPath}`],
-      })
-
-      const barrelFiles = fabric.files.filter((file) => {
-        return file.sources.some((source) => source.isIndexable)
-      })
-
-      await events.emit('debug', {
-        date: new Date(),
-        logs: [`Found ${barrelFiles.length} indexable files for barrel export`],
-      })
-
-      const existingBarrel = fabric.files.find((f) => f.path === rootPath)
-      const existingExports = new Set(
-        existingBarrel?.exports?.flatMap((e) => (Array.isArray(e.name) ? e.name : [e.name])).filter((n): n is string => Boolean(n)) ?? [],
-      )
-
-      const rootFile: KubbFile.File = {
-        path: rootPath,
-        baseName: BARREL_FILENAME,
-        exports: buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }),
-        sources: [],
-        imports: [],
-        meta: {},
-      }
-
-      await fabric.upsertFile(rootFile)
-
-      await events.emit('debug', {
-        date: new Date(),
-        logs: [`✓ Generated barrel file (${rootFile.exports?.length || 0} exports)`],
-      })
-    }
-
-    const files = [...fabric.files]
-
-    await fabric.write({ extension: config.output.extension })
-
-    return {
-      failedPlugins,
-      fabric,
-      files,
-      driver,
-      pluginTimings,
-      sources,
-    }
-  } catch (error) {
-    return {
-      failedPlugins,
-      fabric,
-      files: [],
-      driver,
-      pluginTimings,
-      error: error as Error,
-      sources,
-    }
-  }
-}
-
-type BuildBarrelExportsParams = {
-  barrelFiles: KubbFile.ResolvedFile[]
-  rootDir: string
-  existingExports: Set<string>
-  config: Config
-  driver: PluginDriver
-}
-
-function buildBarrelExports({ barrelFiles, rootDir, existingExports, config, driver }: BuildBarrelExportsParams): KubbFile.Export[] {
-  const pluginNameMap = new Map<string, Plugin>()
-  for (const plugin of driver.plugins) {
-    pluginNameMap.set(plugin.name, plugin)
-  }
-
-  return barrelFiles.flatMap((file) => {
-    const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly)
-
-    return (file.sources ?? []).flatMap((source) => {
-      if (!file.path || !source.isIndexable) {
-        return []
-      }
-
-      const meta = file.meta as FileMetaBase | undefined
-      const plugin = meta?.pluginName ? pluginNameMap.get(meta.pluginName) : undefined
-      const pluginOptions = plugin?.options as { output?: Output<unknown> } | undefined
-
-      if (!pluginOptions || pluginOptions.output?.barrelType === false) {
-        return []
-      }
-
-      const exportName = config.output.barrelType === 'all' ? undefined : source.name ? [source.name] : undefined
-      if (exportName?.some((n) => existingExports.has(n))) {
-        return []
-      }
-
-      return [
-        {
-          name: exportName,
-          path: getRelativePath(rootDir, file.path),
-          isTypeOnly: config.output.barrelType === 'all' ? containsOnlyTypes : source.isTypeOnly,
-        } satisfies KubbFile.Export,
-      ]
-    })
-  })
-}
-
-/**
- * Maps the resolved `Config['input']` shape into an `AdapterSource` that
- * the adapter's `parse()` can consume.
- */
-function inputToAdapterSource(config: Config): AdapterSource {
-  if (Array.isArray(config.input)) {
-    return {
-      type: 'paths',
-      paths: config.input.map((i) => resolve(config.root, i.path)),
-    }
-  }
-
-  if ('data' in config.input) {
-    return { type: 'data', data: config.input.data }
-  }
-
-  const resolved = resolve(config.root, config.input.path)
-  return { type: 'path', path: resolved }
-}

package/src/config.ts

@@ -1,56 +0,0 @@
-import type { PossiblePromise } from '@internals/utils'
-import type { InputPath, UserConfig } from './types.ts'
-
-/**
- * CLI options derived from command-line flags.
- */
-export type CLIOptions = {
-  /** Path to `kubb.config.js` */
-  config?: string
-
-  /** Enable watch mode for input files */
-  watch?: boolean
-
-  /**
-   * Logging verbosity for CLI usage.
-   *
-   * - `silent`: hide non-essential logs
-   * - `info`: show general logs (non-plugin-related)
-   * - `debug`: include detailed plugin lifecycle logs
-   * @default 'silent'
-   */
-  logLevel?: 'silent' | 'info' | 'debug'
-
-  /** Run Kubb with Bun */
-  bun?: boolean
-}
-
-/** All accepted forms of a Kubb configuration. */
-export type ConfigInput = PossiblePromise<UserConfig | UserConfig[]> | ((cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>)
-
-/**
- * Helper for defining a Kubb configuration.
- *
- * Accepts either:
- * - A config object or array of configs
- * - A function returning the config(s), optionally async,
- *   receiving the CLI options as argument
- *
- * @example
- * export default defineConfig(({ logLevel }) => ({
- *   root: 'src',
- *   plugins: [myPlugin()],
- * }))
- */
-export function defineConfig(config: (cli: CLIOptions) => PossiblePromise<UserConfig | UserConfig[]>): typeof config
-export function defineConfig(config: PossiblePromise<UserConfig | UserConfig[]>): typeof config
-export function defineConfig(config: ConfigInput): ConfigInput {
-  return config
-}
-
-/**
- * Type guard to check if a given config has an `input.path`.
- */
-export function isInputPath(config: UserConfig | undefined): config is UserConfig<InputPath> {
-  return typeof config?.input === 'object' && config.input !== null && 'path' in config.input
-}

package/src/createPlugin.ts

@@ -1,28 +0,0 @@
-import type { PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
-
-/**
- * Builder type for a {@link UserPluginWithLifeCycle} — takes options and returns the plugin instance.
- */
-type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
-
-/**
- * Creates a plugin factory. Call the returned function with optional options to get the plugin instance.
- *
- * @example
- * export const myPlugin = createPlugin<MyPlugin>((options) => {
- *   return {
- *     name: 'my-plugin',
- *     options,
- *     resolvePath(baseName) { ... },
- *     resolveName(name, type) { ... },
- *   }
- * })
- *
- * // instantiate
- * const plugin = myPlugin({ output: { path: 'src/gen' } })
- */
-export function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(
-  build: PluginBuilder<T>,
-): (options?: T['options']) => UserPluginWithLifeCycle<T> {
-  return (options) => build(options ?? ({} as T['options']))
-}

package/src/hooks/index.ts

@@ -1,4 +0,0 @@
-export { useKubb } from './useKubb.ts'
-export { useMode } from './useMode.ts'
-export { usePlugin } from './usePlugin.ts'
-export { usePluginDriver } from './usePluginDriver.ts'

package/src/hooks/useKubb.ts

@@ -1,143 +0,0 @@
-import path from 'node:path'
-import type { RootNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { useFabric } from '@kubb/react-fabric'
-import type { GetFileOptions, PluginDriver } from '../PluginDriver.ts'
-import type { Config, Plugin, PluginFactoryOptions, ResolveNameParams, ResolvePathParams } from '../types.ts'
-
-type ResolvePathOptions = {
-  pluginName?: string
-  group?: {
-    tag?: string
-    path?: string
-  }
-  type?: ResolveNameParams['type']
-}
-
-type UseKubbReturn<TOptions extends PluginFactoryOptions = PluginFactoryOptions> = {
-  plugin: Plugin<TOptions>
-  mode: KubbFile.Mode
-  config: Config
-  /**
-   * Returns the plugin whose `name` matches `pluginName`, defaulting to the current plugin.
-   */
-  getPluginByName: (pluginName?: string) => Plugin | undefined
-  /**
-   * Resolves a file reference, defaulting `pluginName` to the current plugin.
-   */
-  getFile: (params: Omit<GetFileOptions<ResolvePathOptions>, 'pluginName'> & { pluginName?: string }) => KubbFile.File<{ pluginName: string }>
-  /**
-   * Resolves a name, defaulting `pluginName` to the current plugin.
-   */
-  resolveName: (params: Omit<ResolveNameParams, 'pluginName'> & { pluginName?: string }) => string
-  /**
-   * Resolves a path, defaulting `pluginName` to the current plugin.
-   */
-  resolvePath: <TPathOptions = object>(params: Omit<ResolvePathParams<TPathOptions>, 'pluginName'> & { pluginName?: string }) => KubbFile.Path
-  /**
-   * Resolves the banner using the plugin's `output.banner` option.
-   * Falls back to the default "Generated by Kubb" banner when `output.banner` is unset.
-   * When `output.banner` is a function and no node is provided, returns the default banner.
-   */
-  resolveBanner: (node?: RootNode) => string | undefined
-  /**
-   * Resolves the footer using the plugin's `output.footer` option.
-   * Returns `undefined` when no footer is configured.
-   * When `output.footer` is a function and no node is provided, returns `undefined`.
-   */
-  resolveFooter: (node?: RootNode) => string | undefined
-}
-
-/**
- * Generates the default "Generated by Kubb" banner from node metadata.
- */
-function buildDefaultBanner({ title, description, version, config }: { title?: string; description?: string; version?: string; config: Config }): string {
-  try {
-    let source = ''
-    if (Array.isArray(config.input)) {
-      const first = config.input[0]
-      if (first && 'path' in first) {
-        source = path.basename(first.path)
-      }
-    } else if ('path' in config.input) {
-      source = path.basename(config.input.path)
-    } else if ('data' in config.input) {
-      source = 'text content'
-    }
-
-    let banner = '/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n'
-
-    if (config.output.defaultBanner === 'simple') {
-      banner += '*/\n'
-      return banner
-    }
-
-    if (source) {
-      banner += `* Source: ${source}\n`
-    }
-
-    if (title) {
-      banner += `* Title: ${title}\n`
-    }
-
-    if (description) {
-      const formattedDescription = description.replace(/\n/gm, '\n* ')
-      banner += `* Description: ${formattedDescription}\n`
-    }
-
-    if (version) {
-      banner += `* OpenAPI spec version: ${version}\n`
-    }
-
-    banner += '*/\n'
-    return banner
-  } catch (_error) {
-    return '/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/'
-  }
-}
-
-export function useKubb<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): UseKubbReturn<TOptions> {
-  const { meta } = useFabric<{
-    plugin: Plugin<TOptions>
-    mode: KubbFile.Mode
-    driver: PluginDriver
-  }>()
-
-  const config = meta.driver.config
-  const defaultPluginName = meta.plugin.name
-
-  const output = (
-    meta.plugin.options as { output?: { banner?: string | ((node: RootNode) => string); footer?: string | ((node: RootNode) => string) } } | undefined
-  )?.output
-
-  return {
-    plugin: meta.plugin as Plugin<TOptions>,
-    mode: meta.mode,
-    config,
-    getPluginByName: (pluginName = defaultPluginName) => meta.driver.getPluginByName.call(meta.driver, pluginName),
-    getFile: ({ pluginName = defaultPluginName, ...rest }) => meta.driver.getFile.call(meta.driver, { pluginName, ...rest }),
-    resolveName: ({ pluginName = defaultPluginName, ...rest }) => meta.driver.resolveName.call(meta.driver, { pluginName, ...rest }),
-    resolvePath: ({ pluginName = defaultPluginName, ...rest }) => meta.driver.resolvePath.call(meta.driver, { pluginName, ...rest }),
-    resolveBanner: (node?: RootNode) => {
-      if (typeof output?.banner === 'function') {
-        return node ? output.banner(node) : buildDefaultBanner({ config })
-      }
-      if (typeof output?.banner === 'string') {
-        return output.banner
-      }
-      if (config.output.defaultBanner === false) {
-        return undefined
-      }
-      return buildDefaultBanner({ config })
-    },
-    resolveFooter: (node?: RootNode) => {
-      if (typeof output?.footer === 'function') {
-        return node ? output.footer(node) : undefined
-      }
-      if (typeof output?.footer === 'string') {
-        return output.footer
-      }
-      return undefined
-    },
-  }
-}

package/src/hooks/useMode.ts

@@ -1,11 +0,0 @@
-import type { KubbFile } from '@kubb/fabric-core/types'
-import { useFabric } from '@kubb/react-fabric'
-
-/**
- * @deprecated use `useKubb` instead
- */
-export function useMode(): KubbFile.Mode {
-  const { meta } = useFabric<{ mode: KubbFile.Mode }>()
-
-  return meta.mode
-}

package/src/hooks/usePlugin.ts

@@ -1,11 +0,0 @@
-import { useFabric } from '@kubb/react-fabric'
-import type { Plugin, PluginFactoryOptions } from '../types.ts'
-
-/**
- * @deprecated use useKubb instead
- */
-export function usePlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions>(): Plugin<TOptions> {
-  const { meta } = useFabric<{ plugin: Plugin<TOptions> }>()
-
-  return meta.plugin
-}

package/src/hooks/usePluginDriver.ts

@@ -1,11 +0,0 @@
-import { useFabric } from '@kubb/react-fabric'
-import type { PluginDriver } from '../PluginDriver.ts'
-
-/**
- * @deprecated use `useKubb` instead
- */
-export function usePluginDriver(): PluginDriver {
-  const { meta } = useFabric<{ driver: PluginDriver }>()
-
-  return meta.driver
-}