@kubb/core 5.0.0-beta.37 → 5.0.0-beta.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "5.0.0-beta.37",
+  "version": "5.0.0-beta.38",
   "description": "Core engine for Kubb's plugin-based code generation system. Provides the plugin driver, file manager, defineConfig, and build orchestration used by every Kubb plugin.",
   "keywords": [
     "code-generator",
@@ -58,14 +58,14 @@
   "dependencies": {
     "fflate": "^0.8.3",
     "tinyexec": "~1.1.2",
-    "@kubb/ast": "5.0.0-beta.37"
+    "@kubb/ast": "5.0.0-beta.38"
   },
   "devDependencies": {
     "@internals/utils": "0.0.0",
-    "@kubb/renderer-jsx": "5.0.0-beta.37"
+    "@kubb/renderer-jsx": "5.0.0-beta.38"
   },
   "peerDependencies": {
-    "@kubb/renderer-jsx": "5.0.0-beta.37"
+    "@kubb/renderer-jsx": "5.0.0-beta.38"
   },
   "size-limit": [
     {

package/src/KubbDriver.ts

@@ -802,17 +802,11 @@ export class KubbDriver {
   getContext<TOptions extends PluginFactoryOptions>(plugin: NormalizedPlugin<TOptions>): Omit<GeneratorContext<TOptions>, 'options'> {
     const driver = this
 
+    // Collect into the active build only. The host renders each collected diagnostic once after the
+    // build (the CLI via `Diagnostics.emit`, the agent via its post-build loop), so emitting a live
+    // `kubb:error`/`kubb:warn`/`kubb:info` here would render it twice.
     const report = (diagnostic: Omit<ProblemDiagnostic, 'plugin'>): void => {
       Diagnostics.report({ ...diagnostic, plugin: plugin.name })
-      if (diagnostic.severity === 'error') {
-        driver.hooks.emit('kubb:error', { error: diagnostic.cause ?? new Error(diagnostic.message) })
-        return
-      }
-      if (diagnostic.severity === 'warning') {
-        driver.hooks.emit('kubb:warn', { message: diagnostic.message })
-        return
-      }
-      driver.hooks.emit('kubb:info', { message: diagnostic.message })
     }
 
     return {

package/src/createReporter.ts

@@ -44,9 +44,9 @@ export type ReporterContext = {
 }
 
 /**
- * Reporter contract. Unlike a Logger (the live TUI view), a reporter never sees the event
- * emitter. `report` is called once per config with its {@link GenerationResult} and produces
- * output (a terminal summary, a JSON report, a log file).
+ * Host-facing reporter, as installed onto a run. Unlike a Logger (the live TUI view), a reporter
+ * never sees the event emitter. `report` runs once per config; `flush`, when present, runs once
+ * after the last config.
  */
 export type Reporter = {
   /**
@@ -57,14 +57,29 @@ export type Reporter = {
    * Called once per config with that config's result and the render context.
    */
   report: (result: GenerationResult, context: ReporterContext) => void | Promise<void>
+  /**
+   * Optional finalizer called once after the run's last config. The host wires it to
+   * `kubb:lifecycle:end`. {@link createReporter} closes it over the reports `report` returned.
+   */
+  flush?: (context: ReporterContext) => void | Promise<void>
 }
 
-export type UserReporter = Reporter
+/**
+ * Reporter definition passed to {@link createReporter}. `report` returns the value to collect for
+ * this config (e.g. a built report), and the optional `flush` receives the collected reports to
+ * emit as one document. `T` is inferred from `report`'s return type.
+ */
+export type UserReporter<T = void> = {
+  name: string
+  report: (result: GenerationResult, context: ReporterContext) => T | Promise<T>
+  flush?: (context: ReporterContext, reports: Array<T>) => void | Promise<void>
+}
 
 /**
- * Defines a reporter. Returns the reporter unchanged at runtime. It exists for type inference and
- * to mark the value as a reporter, mirroring {@link defineLogger}. Wiring the reporter onto the
- * run's events is the host's job, so the reporter only ever deals with a {@link GenerationResult}.
+ * Defines a reporter. When the definition has a `flush`, the returned reporter buffers each value
+ * `report` returns and hands the array to `flush` once, then clears it. Without a `flush`, nothing
+ * is buffered. Wiring the reporter onto the run's events is the host's job, so the reporter only
+ * ever deals with a {@link GenerationResult}.
  *
  * @example
  * ```ts
@@ -73,12 +88,30 @@ export type UserReporter = Reporter
  * export const jsonReporter = createReporter({
  *   name: 'json',
  *   report(result) {
- *     const status = Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success'
- *     process.stdout.write(`${JSON.stringify({ status, diagnostics: result.diagnostics }, null, 2)}\n`)
+ *     return { status: Diagnostics.hasError(result.diagnostics) ? 'failed' : 'success', diagnostics: result.diagnostics }
+ *   },
+ *   flush(context, reports) {
+ *     process.stdout.write(`${JSON.stringify(reports, null, 2)}\n`)
  *   },
  * })
  * ```
  */
-export function createReporter(reporter: UserReporter): Reporter {
-  return reporter
+export function createReporter<T = void>(reporter: UserReporter<T>): Reporter {
+  const flush = reporter.flush
+  if (!flush) {
+    return { name: reporter.name, report: reporter.report }
+  }
+
+  const reports: Array<T> = []
+
+  return {
+    name: reporter.name,
+    async report(result, context) {
+      reports.push(await reporter.report(result, context))
+    },
+    async flush(context) {
+      await flush(context, reports)
+      reports.length = 0
+    },
+  }
 }

package/src/mocks.ts

@@ -3,13 +3,15 @@ import type { FileNode, InputMeta, OperationNode, SchemaNode, Visitor } from '@k
 import { transform } from '@kubb/ast'
 import { FileManager } from './FileManager.ts'
 import { KubbDriver } from './KubbDriver.ts'
-import type { Adapter, AdapterFactoryOptions, Config, Generator, GeneratorContext, NormalizedPlugin, PluginFactoryOptions } from './types.ts'
+import type { Adapter, AdapterFactoryOptions, Config, Generator, GeneratorContext, NormalizedPlugin, PluginFactoryOptions, RendererFactory } from './types.ts'
 
 /**
 
  * Creates a minimal `PluginDriver` mock for unit tests.
  */
 export function createMockedPluginDriver(options: { name?: string; plugin?: NormalizedPlugin; config?: Config } = {}): KubbDriver {
+  const fileManager = new FileManager()
+
   return {
     config: options?.config ?? {
       root: '.',
@@ -21,7 +23,26 @@ export function createMockedPluginDriver(options: { name?: string; plugin?: Norm
       return options?.plugin
     },
     getResolver: (_pluginName: string) => options?.plugin?.resolver,
-    fileManager: new FileManager(),
+    fileManager,
+    async dispatch({ result, renderer }: { result: unknown; renderer?: RendererFactory | null }): Promise<void> {
+      if (!result) return
+
+      if (Array.isArray(result)) {
+        fileManager.upsert(...(result as Array<FileNode>))
+        return
+      }
+
+      if (!renderer) return
+
+      using instance = renderer()
+      if (instance.stream) {
+        for (const file of instance.stream(result)) fileManager.upsert(file)
+        return
+      }
+
+      await instance.render(result)
+      fileManager.upsert(...instance.files)
+    },
   } as unknown as KubbDriver
 }