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

package/src/devtools.ts

@@ -1,7 +1,14 @@
 import type { InputNode } from '@kubb/ast'
 import { deflateSync, inflateSync } from 'fflate'
 import { x } from 'tinyexec'
-import type { DevtoolsOptions } from './types.ts'
+
+export type DevtoolsOptions = {
+  /**
+   * Open the AST inspector in Kubb Studio (`/ast`). Defaults to the main Studio page.
+   * @default false
+   */
+  ast?: boolean
+}
 
 /**
  * Encodes an `InputNode` as a compressed, URL-safe string.

package/src/index.ts

@@ -13,8 +13,8 @@ export { definePlugin } from './definePlugin.ts'
 export { defineResolver } from './defineResolver.ts'
 export { FileManager } from './FileManager.ts'
 export { FileProcessor } from './FileProcessor.ts'
-export { PluginDriver } from './PluginDriver.ts'
+export { KubbDriver } from './KubbDriver.ts'
 export { fsStorage } from './storages/fsStorage.ts'
 export { memoryStorage } from './storages/memoryStorage.ts'
 export * from './types.ts'
-export { isInputPath } from './utils/isInputPath.ts'
+export { isInputPath } from './createKubb.ts'

package/src/mocks.ts

@@ -1,16 +1,15 @@
 import { resolve } from 'node:path'
-import type { FileNode, OperationNode, SchemaNode, Visitor } from '@kubb/ast'
+import type { FileNode, InputMeta, OperationNode, SchemaNode, Visitor } from '@kubb/ast'
 import { transform } from '@kubb/ast'
 import { FileManager } from './FileManager.ts'
-import { PluginDriver } from './PluginDriver.ts'
-import { applyHookResult } from './renderNode.ts'
+import { applyHookResult, KubbDriver } from './KubbDriver.ts'
 import type { Adapter, AdapterFactoryOptions, Config, Generator, GeneratorContext, NormalizedPlugin, PluginFactoryOptions } from './types.ts'
 
 /**
 
  * Creates a minimal `PluginDriver` mock for unit tests.
  */
-export function createMockedPluginDriver(options: { name?: string; plugin?: NormalizedPlugin; config?: Config } = {}): PluginDriver {
+export function createMockedPluginDriver(options: { name?: string; plugin?: NormalizedPlugin; config?: Config } = {}): KubbDriver {
   return {
     config: options?.config ?? {
       root: '.',
@@ -23,7 +22,7 @@ export function createMockedPluginDriver(options: { name?: string; plugin?: Norm
     },
     getResolver: (_pluginName: string) => options?.plugin?.resolver,
     fileManager: new FileManager(),
-  } as unknown as PluginDriver
+  } as unknown as KubbDriver
 }
 
 /**
@@ -35,16 +34,13 @@ export function createMockedAdapter<TOptions extends AdapterFactoryOptions = Ada
   options: {
     name?: TOptions['name']
     resolvedOptions?: TOptions['resolvedOptions']
-    inputNode?: Adapter<TOptions>['inputNode']
     parse?: Adapter<TOptions>['parse']
     getImports?: Adapter<TOptions>['getImports']
   } = {},
 ): Adapter<TOptions> {
-  const inputNode = options.inputNode ?? null
   return {
     name: (options.name ?? 'oas') as TOptions['name'],
     options: (options.resolvedOptions ?? {}) as TOptions['resolvedOptions'],
-    inputNode,
     parse: options.parse ?? (async () => ({ kind: 'Input' as const, schemas: [], operations: [] })),
     getImports: options.getImports ?? ((_node: SchemaNode, _resolve: (schemaName: string) => { name: string; path: string }) => []),
   } as Adapter<TOptions>
@@ -76,7 +72,8 @@ export function createMockedPlugin<TOptions extends PluginFactoryOptions = Plugi
 type RenderGeneratorOptions<TOptions extends PluginFactoryOptions> = {
   config: Config
   adapter: Adapter
-  driver: PluginDriver
+  meta?: InputMeta
+  driver: KubbDriver
   plugin: NormalizedPlugin<TOptions>
   options: TOptions['resolvedOptions']
   resolver: TOptions['resolver']
@@ -88,13 +85,13 @@ function createMockedPluginContext<TOptions extends PluginFactoryOptions>(opts:
   return {
     config: opts.config,
     root,
-    getMode: (output: { path: string }) => PluginDriver.getMode(resolve(root, output.path)),
+    getMode: (output: { path: string }) => KubbDriver.getMode(resolve(root, output.path)),
     adapter: opts.adapter,
     resolver: opts.resolver,
     plugin: opts.plugin,
     driver: opts.driver,
     getResolver: (name: string) => opts.driver.getResolver(name),
-    inputNode: { kind: 'Input', schemas: [], operations: [] },
+    meta: opts.meta ?? { circularNames: [], enumNames: [] },
     addFile: async (...files: Array<FileNode>) => opts.driver.fileManager.add(...files),
     upsertFile: async (...files: Array<FileNode>) => opts.driver.fileManager.upsert(...files),
     hooks: opts.driver.hooks ?? ({} as never),
@@ -126,7 +123,7 @@ export async function renderGeneratorSchema<TOptions extends PluginFactoryOption
     ...context,
     options: opts.options,
   })
-  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
+  await applyHookResult({ result, driver: opts.driver, rendererFactory: generator.renderer })
 }
 
 /**
@@ -150,7 +147,7 @@ export async function renderGeneratorOperation<TOptions extends PluginFactoryOpt
     ...context,
     options: opts.options,
   })
-  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
+  await applyHookResult({ result, driver: opts.driver, rendererFactory: generator.renderer })
 }
 
 /**
@@ -174,5 +171,5 @@ export async function renderGeneratorOperations<TOptions extends PluginFactoryOp
     ...context,
     options: opts.options,
   })
-  await applyHookResult(result, opts.driver, generator.renderer ?? undefined)
+  await applyHookResult({ result, driver: opts.driver, rendererFactory: generator.renderer })
 }

package/src/storages/fsStorage.ts

@@ -4,13 +4,6 @@ import { join, resolve } from 'node:path'
 import { clean, write } from '@internals/utils'
 import { createStorage } from '../createStorage.ts'
 
-/**
- * Detects the filesystem error used to indicate that a path does not exist.
- */
-function isMissingPathError(error: unknown): error is NodeJS.ErrnoException {
-  return typeof error === 'object' && error !== null && 'code' in error && (error as NodeJS.ErrnoException).code === 'ENOENT'
-}
-
 /**
  * Built-in filesystem storage driver.
  *
@@ -42,27 +35,15 @@ export const fsStorage = createStorage(() => ({
     try {
       await access(resolve(key))
       return true
-    } catch (error) {
-      if (isMissingPathError(error)) {
-        return false
-      }
-
-      throw new Error(`Failed to access storage item "${key}"`, {
-        cause: error as Error,
-      })
+    } catch (_error) {
+      return false
     }
   },
   async getItem(key: string) {
     try {
       return await readFile(resolve(key), 'utf8')
-    } catch (error) {
-      if (isMissingPathError(error)) {
-        return null
-      }
-
-      throw new Error(`Failed to read storage item "${key}"`, {
-        cause: error as Error,
-      })
+    } catch (_error) {
+      return null
     }
   },
   async setItem(key: string, value: string) {
@@ -72,36 +53,31 @@ export const fsStorage = createStorage(() => ({
     await rm(resolve(key), { force: true })
   },
   async getKeys(base?: string) {
-    const keys: Array<string> = []
     const resolvedBase = resolve(base ?? process.cwd())
 
-    async function walk(dir: string, prefix: string): Promise<void> {
+    async function* walk(dir: string, prefix: string): AsyncGenerator<string, void, undefined> {
       let entries: Array<Dirent>
       try {
         entries = (await readdir(dir, {
           withFileTypes: true,
         })) as Array<Dirent>
-      } catch (error) {
-        if (isMissingPathError(error)) {
-          return
-        }
-
-        throw new Error(`Failed to list storage keys under "${resolvedBase}"`, {
-          cause: error as Error,
-        })
+      } catch (_error) {
+        return
       }
       for (const entry of entries) {
         const rel = prefix ? `${prefix}/${entry.name}` : entry.name
         if (entry.isDirectory()) {
-          await walk(join(dir, entry.name), rel)
+          yield* walk(join(dir, entry.name), rel)
         } else {
-          keys.push(rel)
+          yield rel
         }
       }
     }
 
-    await walk(resolvedBase, '')
-
+    const keys: Array<string> = []
+    for await (const key of walk(resolvedBase, '')) {
+      keys.push(key)
+    }
     return keys
   },
   async clear(base?: string) {