@kubb/core 5.0.0-alpha.8 → 5.0.0-beta.75

package/src/build.ts

@@ -1,419 +0,0 @@
-import { dirname, relative, resolve } from 'node:path'
-import { AsyncEventEmitter, 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 { BuildError } from './errors.ts'
-import { PluginDriver } from './PluginDriver.ts'
-import { fsStorage } from './storages/fsStorage.ts'
-import type { AdapterSource, Config, DefineStorage, KubbEvents, Output, Plugin, 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: DefineStorage | 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/createGenerator.ts

@@ -1,106 +0,0 @@
-import type { OperationNode, SchemaNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
-import type { FabricReactNode } from '@kubb/react-fabric/types'
-import type { Adapter, Config, Plugin, PluginFactoryOptions } from './types.ts'
-
-export type Version = '1' | '2'
-
-// V2 props — fully typed with @kubb/ast (already a @kubb/core dependency)
-export type OperationsV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  config: Config
-  adapter: Adapter
-  options: Plugin<TPlugin>['options']
-  nodes: Array<OperationNode>
-}
-
-export type OperationV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  config: Config
-  adapter: Adapter
-  options: Plugin<TPlugin>['options']
-  node: OperationNode
-}
-
-export type SchemaV2Props<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  config: Config
-  adapter: Adapter
-  options: Plugin<TPlugin>['options']
-  node: SchemaNode
-}
-
-type UserCoreGeneratorV2<TPlugin extends PluginFactoryOptions> = {
-  name: string
-  type: 'core'
-  version?: '2'
-  operations?(props: OperationsV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  operation?(props: OperationV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  schema?(props: SchemaV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-}
-
-type UserReactGeneratorV2<TPlugin extends PluginFactoryOptions> = {
-  name: string
-  type: 'react'
-  version?: '2'
-  Operations?(props: OperationsV2Props<TPlugin>): FabricReactNode
-  Operation?(props: OperationV2Props<TPlugin>): FabricReactNode
-  Schema?(props: SchemaV2Props<TPlugin>): FabricReactNode
-}
-
-export type CoreGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  name: string
-  type: 'core'
-  version: '2'
-  operations(props: OperationsV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  operation(props: OperationV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-  schema(props: SchemaV2Props<TPlugin>): Promise<Array<KubbFile.File>>
-}
-
-export type ReactGeneratorV2<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = {
-  name: string
-  type: 'react'
-  version: '2'
-  Operations(props: OperationsV2Props<TPlugin>): FabricReactNode
-  Operation(props: OperationV2Props<TPlugin>): FabricReactNode
-  Schema(props: SchemaV2Props<TPlugin>): FabricReactNode
-}
-
-export type Generator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions> = UserCoreGeneratorV2<TPlugin> | UserReactGeneratorV2<TPlugin>
-
-export function createGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(
-  generator: UserReactGeneratorV2<TPlugin>,
-): ReactGeneratorV2<TPlugin>
-
-export function createGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(generator: UserCoreGeneratorV2<TPlugin>): CoreGeneratorV2<TPlugin>
-
-export function createGenerator<TPlugin extends PluginFactoryOptions = PluginFactoryOptions>(
-  generator: UserCoreGeneratorV2<TPlugin> | UserReactGeneratorV2<TPlugin>,
-): unknown {
-  if (generator.type === 'react') {
-    return {
-      version: '2',
-      Operations() {
-        return null
-      },
-      Operation() {
-        return null
-      },
-      Schema() {
-        return null
-      },
-      ...generator,
-    }
-  }
-
-  return {
-    version: '2',
-    async operations() {
-      return []
-    },
-    async operation() {
-      return []
-    },
-    async schema() {
-      return []
-    },
-    ...generator,
-  }
-}

package/src/createLogger.ts

@@ -1,7 +0,0 @@
-import type { Logger, LoggerOptions, UserLogger } from './types.ts'
-
-export function createLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options> {
-  return {
-    ...logger,
-  }
-}

package/src/createPlugin.ts

@@ -1,12 +0,0 @@
-import type { PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
-
-type PluginBuilder<T extends PluginFactoryOptions = PluginFactoryOptions> = (options: T['options']) => UserPluginWithLifeCycle<T>
-
-/**
- * Wraps a plugin builder to make the options parameter optional.
- */
-export function createPlugin<T extends PluginFactoryOptions = PluginFactoryOptions>(
-  build: PluginBuilder<T>,
-): (options?: T['options']) => UserPluginWithLifeCycle<T> {
-  return (options) => build(options ?? ({} as T['options']))
-}

package/src/errors.ts

@@ -1 +0,0 @@
-export { BuildError, ValidationPluginError } from '@internals/utils'

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'