@kubb/mcp 5.0.0-alpha.9 → 5.0.0-beta.1

package/src/tools/generate.ts

@@ -1,5 +1,5 @@
 import { AsyncEventEmitter } from '@internals/utils'
-import { type Config, type KubbEvents, safeBuild, setup } from '@kubb/core'
+import { type Config, createKubb, type KubbHooks } from '@kubb/core'
 import type { CallToolResult } from '@modelcontextprotocol/sdk/types.d.ts'
 import type { z } from 'zod'
 import type { generateSchema } from '../schemas/generateSchema.ts'
@@ -20,7 +20,7 @@ export async function generate(schema: z.infer<typeof generateSchema>, handler:
   const { config: configPath, input, output, logLevel } = schema
 
   try {
-    const events = new AsyncEventEmitter<KubbEvents>()
+    const hooks = new AsyncEventEmitter<KubbHooks>()
     const messages: string[] = []
 
     // Helper to send notifications
@@ -36,50 +36,52 @@ export async function generate(schema: z.infer<typeof generateSchema>, handler:
     }
 
     // Capture events for output and send notifications
-    events.on('info', async (message: string) => {
+    hooks.on('kubb:info', async ({ message }: { message: string }) => {
       await notify(NotifyTypes.INFO, message)
     })
 
-    events.on('success', async (message: string) => {
+    hooks.on('kubb:success', async ({ message }: { message: string }) => {
       await notify(NotifyTypes.SUCCESS, message)
     })
 
-    events.on('error', async (error: Error) => {
+    hooks.on('kubb:error', async ({ error }: { error: Error }) => {
       await notify(NotifyTypes.ERROR, error.message, { stack: error.stack })
     })
 
-    events.on('warn', async (message: string) => {
+    hooks.on('kubb:warn', async ({ message }: { message: string }) => {
       await notify(NotifyTypes.WARN, message)
     })
 
     // Plugin lifecycle events
-    events.on('plugin:start', async ({ name }: { name: string }) => {
-      await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${name}`)
+    hooks.on('kubb:plugin:start', async ({ plugin }) => {
+      await notify(NotifyTypes.PLUGIN_START, `Plugin starting: ${plugin.name}`)
     })
 
-    events.on('plugin:end', async ({ name, duration }: { name: string; duration?: number }) => {
-      await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${name}`, { duration })
+    hooks.on('kubb:plugin:end', async ({ plugin, duration }) => {
+      await notify(NotifyTypes.PLUGIN_END, `Plugin finished: ${plugin.name}`, {
+        duration,
+      })
     })
 
     // File processing events
-    events.on('files:processing:start', async () => {
+    hooks.on('kubb:files:processing:start', async () => {
       await notify(NotifyTypes.FILES_START, 'Starting file processing')
     })
 
-    events.on('file:processing:update', async ({ file }: { file: { name: string } }) => {
+    hooks.on('kubb:file:processing:update', async ({ file }: { file: { name: string } }) => {
       await notify(NotifyTypes.FILE_UPDATE, `Processing file: ${file.name}`)
     })
 
-    events.on('files:processing:end', async () => {
+    hooks.on('kubb:files:processing:end', async () => {
       await notify(NotifyTypes.FILES_END, 'File processing complete')
     })
 
     // Generation events
-    events.on('generation:start', async () => {
+    hooks.on('kubb:generation:start', async () => {
       await notify(NotifyTypes.GENERATION_START, 'Generation started')
     })
 
-    events.on('generation:end', async () => {
+    hooks.on('kubb:generation:end', async () => {
       await notify(NotifyTypes.GENERATION_END, 'Generation ended')
     })
 
@@ -96,7 +98,10 @@ export async function generate(schema: z.infer<typeof generateSchema>, handler:
         throw new Error('Array type in kubb.config.ts is not supported in this tool. Please provide a single configuration object.')
       }
 
-      userConfig = await resolveUserConfig(userConfig, { configPath, logLevel })
+      userConfig = await resolveUserConfig(userConfig, {
+        configPath,
+        logLevel,
+      })
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
       await notify(NotifyTypes.CONFIG_ERROR, errorMessage)
@@ -138,20 +143,12 @@ export async function generate(schema: z.infer<typeof generateSchema>, handler:
     // Setup and build
     await notify(NotifyTypes.SETUP_START, 'Setting up Kubb')
 
-    const { fabric, driver, sources } = await setup({
-      config,
-      events,
-    })
+    const kubb = createKubb(config, { hooks })
+    await kubb.setup()
     await notify(NotifyTypes.SETUP_END, 'Kubb setup complete')
 
     await notify(NotifyTypes.BUILD_START, 'Starting build')
-    const { files, failedPlugins, error } = await safeBuild(
-      {
-        config,
-        events,
-      },
-      { driver, fabric, events, sources },
-    )
+    const { files, failedPlugins, error } = await kubb.safeBuild()
     await notify(NotifyTypes.BUILD_END, `Build complete - Generated ${files.length} files`)
 
     if (error || failedPlugins.size > 0) {

package/src/utils/loadUserConfig.ts

@@ -1,42 +1,64 @@
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import type { Config } from '@kubb/core'
-import createJiti from 'jiti'
+import { unrun } from 'unrun'
+import { ALLOWED_CONFIG_EXTENSIONS } from '../constants.ts'
 import { NotifyTypes } from '../types.ts'
 
 type NotifyFunction = (type: string, message: string, data?: Record<string, unknown>) => Promise<void>
 
-const jiti = createJiti(import.meta.url, {
-  sourceMaps: true,
-})
+const loadedModules = new Map<string, unknown>()
+
+async function loadModule(filePath: string): Promise<unknown> {
+  const ext = path.extname(filePath)
+  if (!ALLOWED_CONFIG_EXTENSIONS.has(ext)) {
+    throw new Error(`Invalid config file extension "${ext}". Allowed: ${[...ALLOWED_CONFIG_EXTENSIONS].join(', ')}`)
+  }
+  if (loadedModules.has(filePath)) {
+    return loadedModules.get(filePath)
+  }
+  const { module } = await unrun({ path: filePath })
+  loadedModules.set(filePath, module)
+  return module
+}
 
-/**
- * Load the user configuration from the specified path or current directory
- */
 export async function loadUserConfig(configPath: string | undefined, { notify }: { notify: NotifyFunction }): Promise<{ userConfig: Config; cwd: string }> {
   let userConfig: Config | undefined
   let cwd: string
 
   if (configPath) {
-    // Resolve the config path to absolute path and get its directory
-    cwd = path.dirname(path.resolve(configPath))
+    const ext = path.extname(configPath)
+    if (!ALLOWED_CONFIG_EXTENSIONS.has(ext)) {
+      const msg = `Invalid config file extension "${ext}". Allowed: ${[...ALLOWED_CONFIG_EXTENSIONS].join(', ')}`
+      await notify(NotifyTypes.CONFIG_ERROR, msg)
+      throw new Error(msg)
+    }
+    const base = path.resolve(process.cwd())
+    const resolvedConfigPath = path.resolve(base, configPath)
+    const relative = path.relative(base, resolvedConfigPath)
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+      const msg = 'Invalid config file path: must be within the current working directory'
+      await notify(NotifyTypes.CONFIG_ERROR, msg)
+      throw new Error(msg)
+    }
+    cwd = path.dirname(resolvedConfigPath)
 
-    // Try to load from path
     try {
-      userConfig = await jiti.import(configPath, { default: true })
-      await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${configPath}`)
+      userConfig = (await loadModule(resolvedConfigPath)) as Config
+      await notify(NotifyTypes.CONFIG_LOADED, `Loaded config from ${resolvedConfigPath}`)
     } catch (error) {
       await notify(NotifyTypes.CONFIG_ERROR, `Failed to load config: ${error instanceof Error ? error.message : String(error)}`)
       throw new Error(`Failed to load config: ${error instanceof Error ? error.message : String(error)}`)
     }
   } else {
-    // Look for kubb.config in current directory with various extensions
     cwd = process.cwd()
-    const configFileNames = ['kubb.config.ts', 'kubb.config.js', 'kubb.config.cjs']
+    const configFileNames = ['kubb.config.ts', 'kubb.config.mts', 'kubb.config.cts', 'kubb.config.js', 'kubb.config.cjs']
 
     for (const configFileName of configFileNames) {
+      const configFilePath = path.resolve(process.cwd(), configFileName)
+      if (!existsSync(configFilePath)) continue
       try {
-        const configFilePath = path.resolve(process.cwd(), configFileName)
-        userConfig = await jiti.import(configFilePath, { default: true })
+        userConfig = (await loadModule(configFilePath)) as Config
         await notify(NotifyTypes.CONFIG_LOADED, `Loaded ${configFileName} from current directory`)
         break
       } catch {

package/src/utils/resolveUserConfig.ts

@@ -1,5 +1,5 @@
 import { isPromise } from '@internals/utils'
-import type { CLIOptions, Config, UserConfig } from '@kubb/core'
+import type { CLIOptions, Config } from '@kubb/core'
 
 export type ResolveUserConfigOptions = {
   configPath?: string
@@ -9,11 +9,14 @@ export type ResolveUserConfigOptions = {
 /**
  * Resolve the config by handling function configs and returning the final configuration
  */
-export async function resolveUserConfig(userConfig: UserConfig, options: ResolveUserConfigOptions): Promise<Config> {
-  let kubbUserConfig = Promise.resolve(userConfig) as Promise<UserConfig>
+export async function resolveUserConfig(config: Config, options: ResolveUserConfigOptions): Promise<Config> {
+  let kubbUserConfig = Promise.resolve(config) as Promise<Config>
 
-  if (typeof userConfig === 'function') {
-    const possiblePromise = (userConfig as any)({ logLevel: options.logLevel, config: options.configPath } as CLIOptions)
+  if (typeof config === 'function') {
+    const possiblePromise = (config as any)({
+      logLevel: options.logLevel,
+      config: options.configPath,
+    } as CLIOptions)
     if (isPromise(possiblePromise)) {
       kubbUserConfig = possiblePromise
     } else {