@kubb/core 5.0.0-alpha.3 → 5.0.0-alpha.31

package/src/defineResolver.ts

@@ -0,0 +1,454 @@
+import path from 'node:path'
+import { camelCase, pascalCase } from '@internals/utils'
+import { isOperationNode, isSchemaNode } from '@kubb/ast'
+import type { Node, OperationNode, RootNode, SchemaNode } from '@kubb/ast/types'
+import type * as KubbFile from './KubbFile.ts'
+import { getMode } from './PluginDriver.ts'
+import type {
+  Config,
+  PluginFactoryOptions,
+  ResolveBannerContext,
+  ResolveNameParams,
+  ResolveOptionsContext,
+  Resolver,
+  ResolverContext,
+  ResolverFileParams,
+  ResolverPathParams,
+} from './types.ts'
+
+/**
+ * Builder type for the plugin-specific resolver fields.
+ *
+ * `default`, `resolveOptions`, `resolvePath`, `resolveFile`, `resolveBanner`, and `resolveFooter`
+ * are optional — built-in fallbacks are injected when omitted.
+ */
+type ResolverBuilder<T extends PluginFactoryOptions> = () => Omit<
+  T['resolver'],
+  'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter' | 'name' | 'pluginName'
+> &
+  Partial<Pick<T['resolver'], 'default' | 'resolveOptions' | 'resolvePath' | 'resolveFile' | 'resolveBanner' | 'resolveFooter'>> & {
+    name: string
+    pluginName: T['name']
+  } & ThisType<T['resolver']>
+
+/**
+ * Checks if an operation matches a pattern for a given filter type (`tag`, `operationId`, `path`, `method`).
+ */
+function matchesOperationPattern(node: OperationNode, type: string, pattern: string | RegExp): boolean {
+  switch (type) {
+    case 'tag':
+      return node.tags.some((tag) => !!tag.match(pattern))
+    case 'operationId':
+      return !!node.operationId.match(pattern)
+    case 'path':
+      return !!node.path.match(pattern)
+    case 'method':
+      return !!(node.method.toLowerCase() as string).match(pattern)
+    case 'contentType':
+      return !!node.requestBody?.contentType?.match(pattern)
+    default:
+      return false
+  }
+}
+
+/**
+ * Checks if a schema matches a pattern for a given filter type (`schemaName`).
+ *
+ * Returns `null` when the filter type doesn't apply to schemas.
+ */
+function matchesSchemaPattern(node: SchemaNode, type: string, pattern: string | RegExp): boolean | null {
+  switch (type) {
+    case 'schemaName':
+      return node.name ? !!node.name.match(pattern) : false
+    default:
+      return null
+  }
+}
+
+/**
+ * Default name resolver used by `defineResolver`.
+ *
+ * - `camelCase` for `function` and `file` types.
+ * - `PascalCase` for `type`.
+ * - `camelCase` for everything else.
+ */
+function defaultResolver(name: ResolveNameParams['name'], type: ResolveNameParams['type']): string {
+  let resolvedName = camelCase(name)
+
+  if (type === 'file' || type === 'function') {
+    resolvedName = camelCase(name, {
+      isFile: type === 'file',
+    })
+  }
+
+  if (type === 'type') {
+    resolvedName = pascalCase(name)
+  }
+
+  return resolvedName
+}
+
+/**
+ * Default option resolver — applies include/exclude filters and merges matching override options.
+ *
+ * Returns `null` when the node is filtered out by an `exclude` rule or not matched by any `include` rule.
+ *
+ * @example Include/exclude filtering
+ * ```ts
+ * const options = defaultResolveOptions(operationNode, {
+ *   options: { output: 'types' },
+ *   exclude: [{ type: 'tag', pattern: 'internal' }],
+ * })
+ * // → null when node has tag 'internal'
+ * ```
+ *
+ * @example Override merging
+ * ```ts
+ * const options = defaultResolveOptions(operationNode, {
+ *   options: { enumType: 'asConst' },
+ *   override: [{ type: 'operationId', pattern: 'listPets', options: { enumType: 'enum' } }],
+ * })
+ * // → { enumType: 'enum' } when operationId matches
+ * ```
+ */
+export function defaultResolveOptions<TOptions>(
+  node: Node,
+  { options, exclude = [], include, override = [] }: ResolveOptionsContext<TOptions>,
+): TOptions | null {
+  if (isOperationNode(node)) {
+    const isExcluded = exclude.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))
+    if (isExcluded) {
+      return null
+    }
+
+    if (include && !include.some(({ type, pattern }) => matchesOperationPattern(node, type, pattern))) {
+      return null
+    }
+
+    const overrideOptions = override.find(({ type, pattern }) => matchesOperationPattern(node, type, pattern))?.options
+
+    return { ...options, ...overrideOptions }
+  }
+
+  if (isSchemaNode(node)) {
+    if (exclude.some(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)) {
+      return null
+    }
+
+    if (include) {
+      const results = include.map(({ type, pattern }) => matchesSchemaPattern(node, type, pattern))
+      const applicable = results.filter((r) => r !== null)
+      if (applicable.length > 0 && !applicable.includes(true)) {
+        return null
+      }
+    }
+
+    const overrideOptions = override.find(({ type, pattern }) => matchesSchemaPattern(node, type, pattern) === true)?.options
+
+    return { ...options, ...overrideOptions }
+  }
+
+  return options
+}
+
+/**
+ * Default path resolver used by `defineResolver`.
+ *
+ * - Returns the output directory in `single` mode.
+ * - Resolves into a tag- or path-based subdirectory when `group` and a `tag`/`path` value are provided.
+ * - Falls back to a flat `output/baseName` path otherwise.
+ *
+ * A custom `group.name` function overrides the default subdirectory naming.
+ * For `tag` groups the default is `${camelCase(tag)}Controller`.
+ * For `path` groups the default is the first path segment after `/`.
+ *
+ * @example Flat output
+ * ```ts
+ * defaultResolvePath({ baseName: 'petTypes.ts' }, { root: '/src', output: { path: 'types' } })
+ * // → '/src/types/petTypes.ts'
+ * ```
+ *
+ * @example Tag-based grouping
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → '/src/types/petsController/petTypes.ts'
+ * ```
+ *
+ * @example Path-based grouping
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', path: '/pets/list' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'path' } },
+ * )
+ * // → '/src/types/pets/petTypes.ts'
+ * ```
+ *
+ * @example Single-file mode
+ * ```ts
+ * defaultResolvePath(
+ *   { baseName: 'petTypes.ts', pathMode: 'single' },
+ *   { root: '/src', output: { path: 'types' } },
+ * )
+ * // → '/src/types'
+ * ```
+ */
+export function defaultResolvePath({ baseName, pathMode, tag, path: groupPath }: ResolverPathParams, { root, output, group }: ResolverContext): KubbFile.Path {
+  const mode = pathMode ?? getMode(path.resolve(root, output.path))
+
+  if (mode === 'single') {
+    return path.resolve(root, output.path) as KubbFile.Path
+  }
+
+  if (group && (groupPath || tag)) {
+    return path.resolve(root, output.path, group.name({ group: group.type === 'path' ? groupPath! : tag! }), baseName) as KubbFile.Path
+  }
+
+  return path.resolve(root, output.path, baseName) as KubbFile.Path
+}
+
+/**
+ * Default file resolver used by `defineResolver`.
+ *
+ * Resolves a `KubbFile.File` by combining name resolution (`resolver.default`) with
+ * path resolution (`resolver.resolvePath`). The resolved file always has empty
+ * `sources`, `imports`, and `exports` arrays — consumers populate those separately.
+ *
+ * In `single` mode the name is omitted and the file sits directly in the output directory.
+ *
+ * @example Resolve a schema file
+ * ```ts
+ * const file = defaultResolveFile.call(resolver,
+ *   { name: 'pet', extname: '.ts' },
+ *   { root: '/src', output: { path: 'types' } },
+ * )
+ * // → { baseName: 'pet.ts', path: '/src/types/pet.ts', sources: [], ... }
+ * ```
+ *
+ * @example Resolve an operation file with tag grouping
+ * ```ts
+ * const file = defaultResolveFile.call(resolver,
+ *   { name: 'listPets', extname: '.ts', tag: 'pets' },
+ *   { root: '/src', output: { path: 'types' }, group: { type: 'tag' } },
+ * )
+ * // → { baseName: 'listPets.ts', path: '/src/types/petsController/listPets.ts', ... }
+ * ```
+ */
+export function defaultResolveFile(this: Resolver, { name, extname, tag, path: groupPath }: ResolverFileParams, context: ResolverContext): KubbFile.File {
+  const pathMode = getMode(path.resolve(context.root, context.output.path))
+  const resolvedName = pathMode === 'single' ? '' : this.default(name, 'file')
+  const baseName = `${resolvedName}${extname}` as KubbFile.BaseName
+  const filePath = this.resolvePath({ baseName, pathMode, tag, path: groupPath }, context)
+
+  return {
+    path: filePath,
+    baseName: path.basename(filePath) as KubbFile.BaseName,
+    meta: {
+      pluginName: this.pluginName,
+    },
+    sources: [],
+    imports: [],
+    exports: [],
+  }
+}
+
+/**
+ * Generates the default "Generated by Kubb" banner from config and optional node metadata.
+ */
+export 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*/'
+  }
+}
+
+/**
+ * Default banner resolver — returns the banner string for a generated file.
+ *
+ * A user-supplied `output.banner` overrides the default Kubb "Generated by Kubb" notice.
+ * When no `output.banner` is set, the Kubb notice is used (including `title` and `version`
+ * from the OAS spec when a `node` is provided).
+ *
+ * - When `output.banner` is a function and `node` is provided, returns `output.banner(node)`.
+ * - When `output.banner` is a function and `node` is absent, falls back to the Kubb notice.
+ * - When `output.banner` is a string, returns it directly.
+ * - When `config.output.defaultBanner` is `false`, returns `undefined`.
+ * - Otherwise returns the Kubb "Generated by Kubb" notice.
+ *
+ * @example String banner overrides default
+ * ```ts
+ * defaultResolveBanner(undefined, { output: { banner: '// my banner' }, config })
+ * // → '// my banner'
+ * ```
+ *
+ * @example Function banner with node
+ * ```ts
+ * defaultResolveBanner(rootNode, { output: { banner: (node) => `// v${node.version}` }, config })
+ * // → '// v3.0.0'
+ * ```
+ *
+ * @example No user banner — Kubb notice with OAS metadata
+ * ```ts
+ * defaultResolveBanner(rootNode, { config })
+ * // → '/** Generated by Kubb ... Title: Pet Store ... *\/'
+ * ```
+ *
+ * @example Disabled default banner
+ * ```ts
+ * defaultResolveBanner(undefined, { config: { output: { defaultBanner: false }, ...config } })
+ * // → undefined
+ * ```
+ */
+export function defaultResolveBanner(node: RootNode | undefined, { output, config }: ResolveBannerContext): string | undefined {
+  if (typeof output?.banner === 'function') {
+    return output.banner(node)
+  }
+
+  if (typeof output?.banner === 'string') {
+    return output.banner
+  }
+
+  if (config.output.defaultBanner === false) {
+    return undefined
+  }
+
+  return buildDefaultBanner({ title: node?.meta?.title, version: node?.meta?.version, config })
+}
+
+/**
+ * Default footer resolver — returns the footer string for a generated file.
+ *
+ * - When `output.footer` is a function and `node` is provided, calls it with the node.
+ * - When `output.footer` is a function and `node` is absent, returns `undefined`.
+ * - When `output.footer` is a string, returns it directly.
+ * - Otherwise returns `undefined`.
+ *
+ * @example String footer
+ * ```ts
+ * defaultResolveFooter(undefined, { output: { footer: '// end of file' }, config })
+ * // → '// end of file'
+ * ```
+ *
+ * @example Function footer with node
+ * ```ts
+ * defaultResolveFooter(rootNode, { output: { footer: (node) => `// ${node.title}` }, config })
+ * // → '// Pet Store'
+ * ```
+ */
+export function defaultResolveFooter(node: RootNode | undefined, { output }: ResolveBannerContext): string | undefined {
+  if (typeof output?.footer === 'function') {
+    return node ? output.footer(node) : undefined
+  }
+  if (typeof output?.footer === 'string') {
+    return output.footer
+  }
+  return undefined
+}
+
+/**
+ * Defines a resolver for a plugin, injecting built-in defaults for name casing,
+ * include/exclude/override filtering, path resolution, and file construction.
+ *
+ * All four defaults can be overridden by providing them in the builder function:
+ * - `default` — name casing strategy (camelCase / PascalCase)
+ * - `resolveOptions` — include/exclude/override filtering
+ * - `resolvePath` — output path computation
+ * - `resolveFile` — full `KubbFile.File` construction
+ *
+ * Methods in the builder have access to `this` (the full resolver object), so they
+ * can call other resolver methods without circular imports.
+ *
+ * @example Basic resolver with naming helpers
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'default',
+ *   resolveName(node) {
+ *     return this.default(node.name, 'function')
+ *   },
+ *   resolveTypedName(node) {
+ *     return this.default(node.name, 'type')
+ *   },
+ * }))
+ * ```
+ *
+ * @example Override resolvePath for a custom output structure
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'custom',
+ *   resolvePath({ baseName }, { root, output }) {
+ *     return path.resolve(root, output.path, 'generated', baseName)
+ *   },
+ * }))
+ * ```
+ *
+ * @example Use this.default inside a helper
+ * ```ts
+ * export const resolver = defineResolver<PluginTs>(() => ({
+ *   name: 'default',
+ *   resolveParamName(node, param) {
+ *     return this.default(`${node.operationId} ${param.in} ${param.name}`, 'type')
+ *   },
+ * }))
+ * ```
+ */
+export function defineResolver<T extends PluginFactoryOptions>(build: ResolverBuilder<T>): T['resolver'] {
+  return {
+    default: defaultResolver,
+    resolveOptions: defaultResolveOptions,
+    resolvePath: defaultResolvePath,
+    resolveFile: defaultResolveFile,
+    resolveBanner: defaultResolveBanner,
+    resolveFooter: defaultResolveFooter,
+    ...build(),
+  } as T['resolver']
+}

package/src/hooks/index.ts

@@ -1,8 +1,3 @@
-export { useKubb } from './useKubb.ts'
-
-/** @deprecated Use `useKubb` from `@kubb/core/hooks` instead */
+export { useDriver } from './useDriver.ts'
 export { useMode } from './useMode.ts'
-/** @deprecated Use `useKubb` from `@kubb/core/hooks` instead */
 export { usePlugin } from './usePlugin.ts'
-/** @deprecated Use `useKubb` from `@kubb/core/hooks` instead */
-export { usePluginManager } from './usePluginManager.ts'

package/src/hooks/useDriver.ts

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

package/src/hooks/useMode.ts

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

package/src/hooks/usePlugin.ts

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

package/src/index.ts

@@ -1,22 +1,34 @@
 export { AsyncEventEmitter, URLPath } from '@internals/utils'
-export { definePrinter } from '@kubb/ast'
+export { composeTransformers, definePrinter } from '@kubb/ast'
 export { build, build as default, safeBuild, setup } from './build.ts'
-export { type CLIOptions, type ConfigInput, defineConfig, isInputPath } from './config.ts'
 export { formatters, linters, logLevel } from './constants.ts'
-export { defineAdapter } from './defineAdapter.ts'
+export { createAdapter } from './createAdapter.ts'
+export { createPlugin } from './createPlugin.ts'
+export { createStorage } from './createStorage.ts'
+export { defineConfig } from './defineConfig.ts'
+export { defineGenerator, mergeGenerators } from './defineGenerator.ts'
 export { defineLogger } from './defineLogger.ts'
-export { definePlugin } from './definePlugin.ts'
-export { defineStorage } from './defineStorage.ts'
-export { PackageManager } from './PackageManager.ts'
-export { getMode, PluginManager } from './PluginManager.ts'
-export { PromiseManager } from './PromiseManager.ts'
+export { defineParser } from './defineParser.ts'
+export { definePresets } from './definePresets.ts'
+export {
+  buildDefaultBanner,
+  defaultResolveBanner,
+  defaultResolveFile,
+  defaultResolveFooter,
+  defaultResolveOptions,
+  defaultResolvePath,
+  defineResolver,
+} from './defineResolver.ts'
+export * as KubbFile from './KubbFile.ts'
+export { getMode, PluginDriver } from './PluginDriver.ts'
 export { fsStorage } from './storages/fsStorage.ts'
 export { memoryStorage } from './storages/memoryStorage.ts'
 export * from './types.ts'
-export type { FunctionParamsAST } from './utils/FunctionParams.ts'
 export { FunctionParams } from './utils/FunctionParams.ts'
 export { detectFormatter } from './utils/formatters.ts'
-export type { FileMetaBase } from './utils/getBarrelFiles.ts'
 export { getBarrelFiles } from './utils/getBarrelFiles.ts'
 export { getConfigs } from './utils/getConfigs.ts'
+export { getPreset } from './utils/getPreset.ts'
+export { isInputPath } from './utils/isInputPath.ts'
 export { detectLinter } from './utils/linters.ts'
+export { satisfiesDependency } from './utils/packageJSON.ts'

package/src/renderNode.tsx

@@ -0,0 +1,25 @@
+import { createReactFabric, Fabric } from '@kubb/react-fabric'
+import type { FabricReactNode, Fabric as FabricType } from '@kubb/react-fabric/types'
+import type * as KubbFile from './KubbFile.ts'
+
+/**
+ * Handles the return value of a plugin AST hook or generator method.
+ *
+ * - React element → rendered via an isolated react-fabric context, files merged into `fabric`
+ * - `Array<KubbFile.File>` → upserted directly into `fabric`
+ * - `void` / `null` / `undefined` → no-op (plugin handled it via `this.upsertFile`)
+ */
+export async function applyHookResult(result: FabricReactNode | Array<KubbFile.File> | void, fabric: FabricType): Promise<void> {
+  if (!result) return
+
+  if (Array.isArray(result)) {
+    await fabric.upsertFile(...(result as Array<KubbFile.File>))
+    return
+  }
+
+  // Non-array truthy result is treated as a React element (FabricReactNode)
+  const fabricChild = createReactFabric()
+  await fabricChild.render(<Fabric>{result as FabricReactNode}</Fabric>)
+  fabric.context.fileManager.upsert(...fabricChild.files)
+  fabricChild.unmount()
+}

package/src/storages/fsStorage.ts

@@ -2,7 +2,7 @@ import type { Dirent } from 'node:fs'
 import { access, readdir, readFile, rm } from 'node:fs/promises'
 import { join, resolve } from 'node:path'
 import { clean, write } from '@internals/utils'
-import { defineStorage } from '../defineStorage.ts'
+import { createStorage } from '../createStorage.ts'
 
 /**
  * Built-in filesystem storage driver.
@@ -27,7 +27,7 @@ import { defineStorage } from '../defineStorage.ts'
  * })
  * ```
  */
-export const fsStorage = defineStorage(() => ({
+export const fsStorage = createStorage(() => ({
   name: 'fs',
   async hasItem(key: string) {
     try {

package/src/storages/memoryStorage.ts

@@ -1,4 +1,4 @@
-import { defineStorage } from '../defineStorage.ts'
+import { createStorage } from '../createStorage.ts'
 
 /**
  * In-memory storage driver. Useful for testing and dry-run scenarios where
@@ -17,7 +17,7 @@ import { defineStorage } from '../defineStorage.ts'
  * })
  * ```
  */
-export const memoryStorage = defineStorage(() => {
+export const memoryStorage = createStorage(() => {
   const store = new Map<string, string>()
 
   return {