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

package/src/createRenderer.ts

@@ -0,0 +1,57 @@
+import type { FileNode } from '@kubb/ast'
+
+/**
+ * Minimal interface any Kubb renderer must satisfy.
+ *
+ * The generic `TElement` is the type of the element the renderer accepts —
+ * e.g. `KubbReactElement` for `@kubb/renderer-jsx`, or a custom type for
+ * your own renderer.  Defaults to `unknown` so that generators which do not
+ * care about the element type continue to work without specifying it.
+ *
+ * This allows core to drive rendering without a hard dependency on
+ * `@kubb/renderer-jsx` or any specific renderer implementation.
+ */
+export type Renderer<TElement = unknown> = {
+  render(element: TElement): Promise<void>
+  unmount(error?: Error | number | null): void
+  readonly files: Array<FileNode>
+}
+
+/**
+ * A factory function that produces a fresh {@link Renderer} per render.
+ *
+ * Generators use this to declare which renderer handles their output.
+ */
+export type RendererFactory<TElement = unknown> = () => Renderer<TElement>
+
+/**
+ * Creates a renderer factory for use in generator definitions.
+ *
+ * Wrap your renderer factory function with this helper to register it as the
+ * renderer for a generator. Core will call this factory once per render cycle
+ * to obtain a fresh renderer instance.
+ *
+ * @example
+ * ```ts
+ * // packages/renderer-jsx/src/index.ts
+ * export const jsxRenderer = createRenderer(() => {
+ *   const runtime = new Runtime()
+ *   return {
+ *     async render(element) { await runtime.render(element) },
+ *     get files() { return runtime.nodes },
+ *     unmount(error) { runtime.unmount(error) },
+ *   }
+ * })
+ *
+ * // packages/plugin-zod/src/generators/zodGenerator.tsx
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ * export const zodGenerator = defineGenerator<PluginZod>({
+ *   name: 'zod',
+ *   renderer: jsxRenderer,
+ *   schema(node, options) { return <File ...>...</File> },
+ * })
+ * ```
+ */
+export function createRenderer<TElement = unknown>(factory: RendererFactory<TElement>): RendererFactory<TElement> {
+  return factory
+}

package/src/createStorage.ts

@@ -1,43 +1,51 @@
-/**
- * Storage interface for persisting Kubb output.
- *
- * Keys are root-relative forward-slash paths (e.g. `src/gen/api/getPets.ts`).
- * Implement this interface to route generated files to any backend — filesystem,
- * S3, Redis, in-memory, etc.
- *
- * Use `createStorage` to create a typed storage driver.
- */
-export interface DefineStorage {
-  /** Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`). */
+export type Storage = {
+  /**
+   * Identifier used for logging and debugging (e.g. `'fs'`, `'s3'`).
+   */
   readonly name: string
-  /** Returns `true` when an entry for `key` exists in storage. */
+  /**
+   * Returns `true` when an entry for `key` exists in storage.
+   */
   hasItem(key: string): Promise<boolean>
-  /** Returns the stored string value, or `null` when `key` does not exist. */
+  /**
+   * Returns the stored string value, or `null` when `key` does not exist.
+   */
   getItem(key: string): Promise<string | null>
-  /** Persists `value` under `key`, creating any required structure. */
+  /**
+   * Persists `value` under `key`, creating any required structure.
+   */
   setItem(key: string, value: string): Promise<void>
-  /** Removes the entry for `key`. No-ops when the key does not exist. */
+  /**
+   *  Removes the entry for `key`. No-ops when the key does not exist.
+   */
   removeItem(key: string): Promise<void>
-  /** Returns all keys, optionally filtered to those starting with `base`. */
+  /**
+   * Returns all keys, optionally filtered to those starting with `base`.
+   */
   getKeys(base?: string): Promise<Array<string>>
-  /** Removes all entries, optionally scoped to those starting with `base`. */
+  /**
+   * Removes all entries, optionally scoped to those starting with `base`.
+   */
   clear(base?: string): Promise<void>
-  /** Optional teardown hook called after the build completes. */
+  /**
+   * Optional teardown hook called after the build completes.
+   */
   dispose?(): Promise<void>
 }
 
 /**
- * Wraps a storage builder so the `options` argument is optional, following the
- * same factory pattern as `createPlugin`, `createLogger`, and `createAdapter`.
+ * Factory for implementing custom storage backends that control where generated files are written.
+ *
+ * Takes a builder function `(options: TOptions) => Storage` and returns a factory `(options?: TOptions) => Storage`.
+ * Kubb provides filesystem and in-memory implementations out of the box.
  *
- * The builder receives the resolved options object and must return a
- * `DefineStorage`-compatible object that includes a `name` string.
+ * @note Call the returned factory with optional options to instantiate the storage adapter.
  *
  * @example
  * ```ts
  * import { createStorage } from '@kubb/core'
  *
- * export const memoryStorage = createStorage((_options) => {
+ * export const memoryStorage = createStorage(() => {
  *   const store = new Map<string, string>()
  *   return {
  *     name: 'memory',
@@ -45,12 +53,18 @@ export interface DefineStorage {
  *     async getItem(key) { return store.get(key) ?? null },
  *     async setItem(key, value) { store.set(key, value) },
  *     async removeItem(key) { store.delete(key) },
- *     async getKeys() { return [...store.keys()] },
- *     async clear() { store.clear() },
+ *     async getKeys(base) {
+ *       const keys = [...store.keys()]
+ *       return base ? keys.filter((k) => k.startsWith(base)) : keys
+ *     },
+ *     async clear(base) { if (!base) store.clear() },
  *   }
  * })
+ *
+ * // Instantiate:
+ * const storage = memoryStorage()
  * ```
  */
-export function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => DefineStorage): (options?: TOptions) => DefineStorage {
+export function createStorage<TOptions = Record<string, never>>(build: (options: TOptions) => Storage): (options?: TOptions) => Storage {
   return (options) => build(options ?? ({} as TOptions))
 }

package/src/defineGenerator.ts

@@ -0,0 +1,87 @@
+import type { PossiblePromise } from '@internals/utils'
+import type { FileNode, OperationNode, SchemaNode } from '@kubb/ast'
+import type { RendererFactory } from './createRenderer.ts'
+import type { GeneratorContext, PluginFactoryOptions } from './types.ts'
+
+export type { GeneratorContext } from './types.ts'
+
+/**
+ * Declares a named generator unit that walks the AST and emits files.
+ *
+ * Each method (`schema`, `operation`, `operations`) is called for the matching node type.
+ * Each method returns `TElement | Array<FileNode> | void`. JSX-based generators require a `renderer` factory.
+ * Return `Array<FileNode>` directly or call `ctx.upsertFile()` manually and return `void` to bypass rendering.
+ *
+ * @note Generators are consumed by plugins and registered via `ctx.addGenerator()` in `kubb:plugin:setup`.
+ *
+ * @example
+ * ```ts
+ * import { defineGenerator } from '@kubb/core'
+ * import { jsxRenderer } from '@kubb/renderer-jsx'
+ *
+ * export const typeGenerator = defineGenerator({
+ *   name: 'typescript',
+ *   renderer: jsxRenderer,
+ *   schema(node, ctx) {
+ *     const { adapter, resolver, root, options } = ctx
+ *     return <File ...><Type node={node} resolver={resolver} /></File>
+ *   },
+ * })
+ * ```
+ */
+export type Generator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown> = {
+  /**
+   * Used in diagnostic messages and debug output.
+   */
+  name: string
+  /**
+   * Optional renderer factory that produces a {@link Renderer} for each render cycle.
+   *
+   * Generators that return renderer elements (e.g. JSX via `@kubb/renderer-jsx`) must set this
+   * to the matching renderer factory (e.g. `jsxRenderer` from `@kubb/renderer-jsx`).
+   *
+   * Generators that only return `Array<FileNode>` or `void` do not need to set this.
+   *
+   * Set `renderer: null` to explicitly opt out of rendering even when the parent plugin
+   * declares a `renderer` (overrides the plugin-level fallback).
+   *
+   * @example
+   * ```ts
+   * import { jsxRenderer } from '@kubb/renderer-jsx'
+   * export const myGenerator = defineGenerator<PluginTs>({
+   *   renderer: jsxRenderer,
+   *   schema(node, ctx) { return <File ...>...</File> },
+   * })
+   * ```
+   */
+  renderer?: RendererFactory<TElement> | null
+  /**
+   * Called for each schema node in the AST walk.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
+   */
+  schema?: (node: SchemaNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>
+  /**
+   * Called for each operation node in the AST walk.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the per-node resolved options (after exclude/include/override).
+   */
+  operation?: (node: OperationNode, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>
+  /**
+   * Called once after all operations have been walked.
+   * `ctx` carries the plugin context with `adapter` and `inputNode` guaranteed present,
+   * plus `ctx.options` with the plugin-level options for the batch call.
+   */
+  operations?: (nodes: Array<OperationNode>, ctx: GeneratorContext<TOptions>) => PossiblePromise<TElement | Array<FileNode> | void>
+}
+
+/**
+ * Defines a generator. Returns the object as-is with correct `this` typings.
+ * `applyHookResult` handles renderer elements and `File[]` uniformly using
+ * the generator's declared `renderer` factory.
+ */
+export function defineGenerator<TOptions extends PluginFactoryOptions = PluginFactoryOptions, TElement = unknown>(
+  generator: Generator<TOptions, TElement>,
+): Generator<TOptions, TElement> {
+  return generator
+}

package/src/defineLogger.ts

@@ -0,0 +1,19 @@
+import type { Logger, LoggerOptions, UserLogger } from './types.ts'
+
+/**
+ * Wraps a logger definition into a typed {@link Logger}.
+ *
+ * @example
+ * ```ts
+ * export const myLogger = defineLogger({
+ *   name: 'my-logger',
+ *   install(context, options) {
+ *     context.on('kubb:info', (message) => console.log('ℹ', message))
+ *     context.on('kubb:error', (error) => console.error('✗', error.message))
+ *   },
+ * })
+ * ```
+ */
+export function defineLogger<Options extends LoggerOptions = LoggerOptions>(logger: UserLogger<Options>): Logger<Options> {
+  return logger
+}

package/src/defineMiddleware.ts

@@ -0,0 +1,62 @@
+import type { KubbHooks } from './Kubb.ts'
+
+/**
+ * A middleware instance produced by calling a factory created with `defineMiddleware`.
+ * It declares event handlers under a `hooks` object which are registered on the
+ * shared emitter after all plugin hooks, so middleware handlers for any event
+ * always fire last.
+ */
+export type Middleware = {
+  /**
+   * Unique identifier for this middleware.
+   */
+  name: string
+  /**
+   * Lifecycle event handlers for this middleware.
+   * Any event from the global `KubbHooks` map can be subscribed to here.
+   * Handlers are registered after all plugin handlers, so they always fire last.
+   */
+  hooks: {
+    [K in keyof KubbHooks]?: (...args: KubbHooks[K]) => void | Promise<void>
+  }
+}
+
+/**
+ * Creates a middleware factory using the hook-style `hooks` API.
+ *
+ * Middleware handlers fire after all plugin handlers for any given event, making them ideal for post-processing, logging, and auditing.
+ * Per-build state (such as accumulators) belongs inside the factory closure so each `createKubb` invocation gets its own isolated instance.
+ *
+ * @note The factory can accept typed options. See examples for using options and per-build state patterns.
+ *
+ * @example
+ * ```ts
+ * import { defineMiddleware } from '@kubb/core'
+ *
+ * // Stateless middleware
+ * export const logMiddleware = defineMiddleware(() => ({
+ *   name: 'log-middleware',
+ *   hooks: {
+ *     'kubb:build:end'({ files }) {
+ *       console.log(`Build complete with ${files.length} files`)
+ *     },
+ *   },
+ * }))
+ *
+ * // Middleware with options and per-build state
+ * export const prefixMiddleware = defineMiddleware((options: { prefix: string } = { prefix: '' }) => {
+ *   const seen = new Set<string>()
+ *   return {
+ *     name: 'prefix-middleware',
+ *     hooks: {
+ *       'kubb:plugin:end'({ plugin }) {
+ *         seen.add(`${options.prefix}${plugin.name}`)
+ *       },
+ *     },
+ *   }
+ * })
+ * ```
+ */
+export function defineMiddleware<TOptions extends object = object>(factory: (options: TOptions) => Middleware): (options?: TOptions) => Middleware {
+  return (options) => factory(options ?? ({} as TOptions))
+}

package/src/defineParser.ts

@@ -0,0 +1,44 @@
+import type { FileNode } from '@kubb/ast'
+
+type PrintOptions = {
+  extname?: FileNode['extname']
+}
+
+export type Parser<TMeta extends object = any> = {
+  name: string
+  /**
+   * File extensions this parser handles.
+   * Use `undefined` to create a catch-all fallback parser.
+   *
+   * @example Handled extensions
+   * `['.ts', '.js']`
+   */
+  extNames: Array<FileNode['extname']> | undefined
+  /**
+   * Convert a resolved file to a string.
+   */
+  parse(file: FileNode<TMeta>, options?: PrintOptions): Promise<string> | string
+}
+
+/**
+ * Defines a parser with type safety. Creates parsers that transform generated files to strings based on their extension.
+ *
+ * @note Call the returned factory with optional options to instantiate the parser.
+ *
+ * @example
+ * ```ts
+ * import { defineParser } from '@kubb/core'
+ *
+ * export const jsonParser = defineParser({
+ *   name: 'json',
+ *   extNames: ['.json'],
+ *   parse(file) {
+ *     const { extractStringsFromNodes } = await import('@kubb/ast')
+ *     return file.sources.map((s) => extractStringsFromNodes(s.nodes ?? [])).join('\n')
+ *   },
+ * })
+ * ```
+ */
+export function defineParser<TMeta extends object = any>(parser: Parser<TMeta>): Parser<TMeta> {
+  return parser
+}

package/src/definePlugin.ts

@@ -0,0 +1,83 @@
+import type { KubbHooks } from './Kubb.ts'
+import type { KubbPluginSetupContext, PluginFactoryOptions } from './types.ts'
+
+/**
+ * A plugin object produced by `definePlugin`.
+ * Instead of flat lifecycle methods, it groups all handlers under a `hooks:` property
+ * (matching Astro's integration naming convention).
+ *
+ * @template TFactory - The plugin's `PluginFactoryOptions` type.
+ */
+export type Plugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions> = {
+  /**
+   * Unique name for the plugin, following the same naming convention as `createPlugin`.
+   */
+  name: string
+  /**
+   * Plugins that must be registered before this plugin executes.
+   * An error is thrown at startup when any listed dependency is missing.
+   */
+  dependencies?: Array<string>
+  /**
+   * Controls the execution order of this plugin relative to others.
+   *
+   * - `'pre'`  — runs before all normal plugins.
+   * - `'post'` — runs after all normal plugins.
+   * - `undefined` (default) — runs in declaration order among normal plugins.
+   *
+   * Dependency constraints always take precedence over `enforce`.
+   */
+  enforce?: 'pre' | 'post'
+  /**
+   * The options passed by the user when calling the plugin factory.
+   */
+  options?: TFactory['options']
+  /**
+   * Lifecycle event handlers for this plugin.
+   * Any event from the global `KubbHooks` map can be subscribed to here.
+   */
+  hooks: {
+    [K in Exclude<keyof KubbHooks, 'kubb:plugin:setup'>]?: (...args: KubbHooks[K]) => void | Promise<void>
+  } & {
+    'kubb:plugin:setup'?(ctx: KubbPluginSetupContext<TFactory>): void | Promise<void>
+  }
+}
+
+/**
+ * Returns `true` when `plugin` is a hook-style plugin created with `definePlugin`.
+ *
+ * Used by `PluginDriver` to distinguish hook-style plugins from legacy `createPlugin` plugins
+ * so it can normalize them and register their handlers on the `AsyncEventEmitter`.
+ */
+export function isPlugin(plugin: unknown): plugin is Plugin {
+  return typeof plugin === 'object' && plugin !== null && 'hooks' in plugin
+}
+
+/**
+ * Wraps a factory function and returns a typed `Plugin` with lifecycle handlers grouped under `hooks`.
+ *
+ * Handlers live in a single `hooks` object (inspired by Astro integrations).
+ * All lifecycle events from `KubbHooks` are available for subscription.
+ *
+ * @note For real plugins, use a `PluginFactoryOptions` type parameter to get type-safe context in `kubb:plugin:setup`.
+ * Plugin names should follow the convention `plugin-<feature>` (e.g., `plugin-react-query`, `plugin-zod`).
+ *
+ * @example
+ * ```ts
+ * import { definePlugin } from '@kubb/core'
+ *
+ * export const pluginTs = definePlugin((options: { prefix?: string } = {}) => ({
+ *   name: 'plugin-ts',
+ *   hooks: {
+ *     'kubb:plugin:setup'(ctx) {
+ *       ctx.setResolver(resolverTs)
+ *     },
+ *   },
+ * }))
+ * ```
+ */
+export function definePlugin<TFactory extends PluginFactoryOptions = PluginFactoryOptions>(
+  factory: (options: TFactory['options']) => Plugin<TFactory>,
+): (options?: TFactory['options']) => Plugin<TFactory> {
+  return (options) => factory(options ?? ({} as TFactory['options']))
+}