@kubb/core 3.0.0-alpha.1 → 3.0.0-alpha.11

package/src/__snapshots__/grouped.json

@@ -0,0 +1,114 @@
+{
+  "name": "",
+  "path": "",
+  "children": [
+    {
+      "name": "src",
+      "path": "src",
+      "children": [
+        {
+          "name": "axios",
+          "path": "src/axios",
+          "children": [
+            {
+              "name": "file2.ts",
+              "file": {
+                "path": "src/axios/file2.ts",
+                "baseName": "file2.ts",
+                "sources": [],
+                "id": "6af477de6b602aafbb2e1ce0011b1f411a7ab3a5",
+                "name": "file2",
+                "extName": ".ts",
+                "imports": [],
+                "exports": []
+              },
+              "path": "src/axios/file2.ts"
+            },
+            {
+              "name": "file1.ts",
+              "file": {
+                "path": "src/axios/file1.ts",
+                "baseName": "file2.ts",
+                "sources": [],
+                "id": "a9679944d24c174b2f2fd5b1f19c9861f1d35d0e",
+                "name": "file2",
+                "extName": ".ts",
+                "imports": [],
+                "exports": []
+              },
+              "path": "src/axios/file1.ts"
+            },
+            {
+              "name": "controller",
+              "path": "src/axios/controller",
+              "children": [
+                {
+                  "name": "pet.ts",
+                  "file": {
+                    "path": "src/axios/controller/pet.ts",
+                    "baseName": "pet.ts",
+                    "sources": [],
+                    "id": "8beaaf5e1b1a6b89a11589c2e3dc5fd7f5eb5e8c",
+                    "name": "pet",
+                    "extName": ".ts",
+                    "imports": [],
+                    "exports": []
+                  },
+                  "path": "src/axios/controller/pet.ts"
+                }
+              ]
+            },
+            {
+              "name": "index.ts",
+              "file": {
+                "path": "src/axios/index.ts",
+                "baseName": "index.ts",
+                "sources": [],
+                "id": "b077038b83c1ef4050649be406937a73c1f41ad3",
+                "name": "index",
+                "extName": ".ts",
+                "imports": [],
+                "exports": []
+              },
+              "path": "src/axios/index.ts"
+            }
+          ]
+        },
+        {
+          "name": "controller",
+          "path": "src/controller",
+          "children": [
+            {
+              "name": "test.ts",
+              "file": {
+                "path": "src/controller/test.ts",
+                "baseName": "test.ts",
+                "sources": [],
+                "id": "a2d277093a81a74c56c0d094071195302d6bb484",
+                "name": "test",
+                "extName": ".ts",
+                "imports": [],
+                "exports": []
+              },
+              "path": "src/controller/test.ts"
+            }
+          ]
+        },
+        {
+          "name": "test.ts",
+          "file": {
+            "path": "src/test.ts",
+            "baseName": "test.ts",
+            "sources": [],
+            "id": "f8e2d98f76d6e33f21aa686d674544b5c7d6fa3e",
+            "name": "test",
+            "extName": ".ts",
+            "imports": [],
+            "exports": []
+          },
+          "path": "src/test.ts"
+        }
+      ]
+    }
+  ]
+}

package/src/__snapshots__/ordered.json

@@ -0,0 +1,62 @@
+[
+  {
+    "path": "src/test.ts",
+    "baseName": "test.ts",
+    "sources": [],
+    "id": "f8e2d98f76d6e33f21aa686d674544b5c7d6fa3e",
+    "name": "test",
+    "extName": ".ts",
+    "imports": [],
+    "exports": []
+  },
+  {
+    "path": "src/axios/file2.ts",
+    "baseName": "file2.ts",
+    "sources": [],
+    "id": "6af477de6b602aafbb2e1ce0011b1f411a7ab3a5",
+    "name": "file2",
+    "extName": ".ts",
+    "imports": [],
+    "exports": []
+  },
+  {
+    "path": "src/axios/file1.ts",
+    "baseName": "file2.ts",
+    "sources": [],
+    "id": "a9679944d24c174b2f2fd5b1f19c9861f1d35d0e",
+    "name": "file2",
+    "extName": ".ts",
+    "imports": [],
+    "exports": []
+  },
+  {
+    "path": "src/axios/index.ts",
+    "baseName": "index.ts",
+    "sources": [],
+    "id": "b077038b83c1ef4050649be406937a73c1f41ad3",
+    "name": "index",
+    "extName": ".ts",
+    "imports": [],
+    "exports": []
+  },
+  {
+    "path": "src/controller/test.ts",
+    "baseName": "test.ts",
+    "sources": [],
+    "id": "a2d277093a81a74c56c0d094071195302d6bb484",
+    "name": "test",
+    "extName": ".ts",
+    "imports": [],
+    "exports": []
+  },
+  {
+    "path": "src/axios/controller/pet.ts",
+    "baseName": "pet.ts",
+    "sources": [],
+    "id": "8beaaf5e1b1a6b89a11589c2e3dc5fd7f5eb5e8c",
+    "name": "pet",
+    "extName": ".ts",
+    "imports": [],
+    "exports": []
+  }
+]

package/src/build.ts

@@ -1,15 +1,15 @@
-import c from 'tinyrainbow'
-
 import { clean, read } from '@kubb/fs'
-import { FileManager, type ResolvedFile } from './FileManager.ts'
+import type * as KubbFile from '@kubb/fs/types'
+import { FileManager, processFiles } from './FileManager.ts'
 import { PluginManager } from './PluginManager.ts'
-import { isPromise } from './PromiseManager.ts'
 import { isInputPath } from './config.ts'
-import { LogLevel, createLogger, randomCliColour } from './logger.ts'
+import { createLogger } from './logger.ts'
 import { URLPath } from './utils/URLPath.ts'
 
+import { join, resolve } from 'node:path'
+import { getRelativePath } from '@kubb/fs'
 import type { Logger } from './logger.ts'
-import type { Plugin, PluginContext, PluginParameter, TransformResult } from './types.ts'
+import type { PluginContext } from './types.ts'
 
 type BuildOptions = {
   config: PluginContext['config']
@@ -28,18 +28,8 @@ type BuildOutput = {
   error?: Error
 }
 
-async function transformReducer(
-  this: PluginContext,
-  _previousCode: string,
-  result: TransformResult | Promise<TransformResult>,
-  _plugin: Plugin,
-): Promise<string | null> {
-  return result
-}
-
 async function setup(options: BuildOptions): Promise<PluginManager> {
-  const { config, logger = createLogger({ logLevel: LogLevel.silent }) } = options
-  let count = 0
+  const { config, logger = createLogger() } = options
 
   try {
     if (isInputPath(config) && !new URLPath(config.input.path).isURL) {
@@ -47,196 +37,121 @@ async function setup(options: BuildOptions): Promise<PluginManager> {
     }
   } catch (e) {
     if (isInputPath(config)) {
-      throw new Error(
-        `Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${c.dim(config.input.path)}`,
-        {
-          cause: e,
-        },
-      )
+      throw new Error(`Cannot read file/URL defined in \`input.path\` or set with \`kubb generate PATH\` in the CLI of your Kubb config ${config.input.path}`, {
+        cause: e,
+      })
     }
   }
 
   if (config.output.clean) {
     await clean(config.output.path)
+    await clean(join(config.root, '.kubb'))
   }
 
-  const task = async (file: ResolvedFile): Promise<ResolvedFile> => {
-    const { path } = file
-
-    let source: string | null = await FileManager.getSource(file)
-
-    const { result: loadedResult } = await pluginManager.hookFirst({
-      hookName: 'load',
-      parameters: [path],
-    })
-    if (loadedResult && isPromise(loadedResult)) {
-      source = await loadedResult
-    }
-    if (loadedResult && !isPromise(loadedResult)) {
-      source = loadedResult
-    }
-
-    if (source) {
-      source = await pluginManager.hookReduceArg0({
-        hookName: 'transform',
-        parameters: [path, source],
-        reduce: transformReducer,
-      })
-
-      if (config.output.write || config.output.write === undefined) {
-        if (file.meta?.pluginKey) {
-          // run only for pluginKey defined in the meta of the file
-          await pluginManager.hookForPlugin({
-            pluginKey: file.meta?.pluginKey,
-            hookName: 'writeFile',
-            parameters: [path, source],
-          })
-        }
-
-        await pluginManager.hookFirst({
-          hookName: 'writeFile',
-          parameters: [path, source],
-        })
-      }
-    }
-
-    return {
-      ...file,
-      source: source || '',
-    }
-  }
-
-  const pluginManager = new PluginManager(config, { logger, task })
-
-  pluginManager.on('execute', (executer) => {
-    const { hookName, parameters, plugin } = executer
-
-    if (hookName === 'writeFile') {
-      const [code] = parameters as PluginParameter<'writeFile'>
-
-      logger.emit('debug', [`PluginKey ${c.dim(JSON.stringify(plugin.key))} \nwith source\n\n${code}`])
-    }
-  })
-
-  pluginManager.queue.on('add', () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return
-    }
-
-    if (count === 0) {
-      logger.emit('start', '💾 Writing')
-    }
-  })
-
-  pluginManager.queue.on('active', () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return
-    }
-
-    if (logger.spinner && pluginManager.queue.size > 0) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
-
-      logger.spinner.suffixText = c.dim(text)
-    }
-    ++count
-  })
-
-  pluginManager.queue.on('completed', () => {
-    if (logger.logLevel !== LogLevel.info) {
-      return
-    }
-
-    if (logger.spinner) {
-      const text = `Item: ${count} Size: ${pluginManager.queue.size}  Pending: ${pluginManager.queue.pending}`
-
-      logger.spinner.suffixText = c.dim(text)
-    }
-  })
-
-  pluginManager.on('executed', (executer) => {
-    const { hookName, plugin, output, parameters } = executer
-
-    const logs = [
-      `${randomCliColour(plugin.name)} Executing ${hookName}`,
-      parameters && `${c.bgWhite('Parameters')} ${randomCliColour(plugin.name)} ${hookName}`,
-      JSON.stringify(parameters, undefined, 2),
-      output && `${c.bgWhite('Output')} ${randomCliColour(plugin.name)} ${hookName}`,
-      output,
-    ].filter(Boolean)
-
-    logger.emit('debug', logs as string[])
-  })
-
-  return pluginManager
+  return new PluginManager(config, { logger })
 }
 
 export async function build(options: BuildOptions): Promise<BuildOutput> {
-  const pluginManager = await setup(options)
-
-  const { fileManager, logger } = pluginManager
-
-  await pluginManager.hookParallel({
-    hookName: 'buildStart',
-    parameters: [options.config],
-  })
+  const { files, pluginManager, error } = await safeBuild(options)
 
-  await pluginManager.hookParallel({ hookName: 'buildEnd' })
-
-  if (logger.logLevel === LogLevel.info) {
-    logger.emit('end', '💾 Writing completed')
-  }
-
-  const files = await Promise.all(
-    fileManager.files.map(async (file) => ({
-      ...file,
-      source: await FileManager.getSource(file),
-    })),
-  )
+  if (error) throw error
 
   return {
     files,
     pluginManager,
+    error,
   }
 }
 
 export async function safeBuild(options: BuildOptions): Promise<BuildOutput> {
+  let files = []
   const pluginManager = await setup(options)
 
-  const { fileManager, logger } = pluginManager
-
   try {
+    pluginManager.events.on('executing', ({ plugin, message }) => {
+      pluginManager.logger.emit('debug', { date: new Date(), logs: [`Executing pluginKey ${plugin.key?.join('.')} | ${message}`] })
+    })
+
+    pluginManager.events.on('executed', ({ plugin, message, output }) => {
+      pluginManager.logger.emit('debug', {
+        date: new Date(),
+        logs: [`Executed pluginKey ${plugin.key?.join('.')} | ${message} |  ${JSON.stringify(output, undefined, 2)}`],
+      })
+    })
+
     await pluginManager.hookParallel({
       hookName: 'buildStart',
       parameters: [options.config],
+      message: 'buildStart',
     })
 
-    await pluginManager.hookParallel({ hookName: 'buildEnd' })
+    // create root barrel file
+    const root = resolve(options.config.root)
+    const rootPath = resolve(root, options.config.output.path, 'index.ts')
+    const barrelFiles = pluginManager.fileManager.files.filter((file) => {
+      return file.sources.some((source) => source.isIndexable)
+    })
 
-    if (logger.logLevel === LogLevel.info) {
-      logger.emit('end', '💾 Writing completed')
+    const rootFile: KubbFile.File = {
+      path: rootPath,
+      baseName: 'index.ts',
+      exports: barrelFiles
+        .flatMap((file) => {
+          return file.sources
+            ?.map((source) => {
+              if (!file.path || !source.isIndexable) {
+                return undefined
+              }
+
+              // validate of the file is coming from plugin x, needs pluginKey on every file TODO update typing
+              const plugin = pluginManager.plugins.find((item) => {
+                const meta = file.meta as any
+                return item.name === meta?.pluginKey?.[0]
+              })
+
+              if (plugin?.output?.exportType === false) {
+                return undefined
+              }
+
+              if (FileManager.getMode(plugin?.output?.path) === 'single') {
+                return undefined
+              }
+              return {
+                name: options.config.output.exportType === 'barrel' ? undefined : [source.name],
+                path: getRelativePath(rootPath, file.path),
+                isTypeOnly: source.isTypeOnly,
+              } as KubbFile.Export
+            })
+            .filter(Boolean)
+        })
+        .filter(Boolean),
+      sources: [],
+      meta: {},
     }
-  } catch (e) {
-    const files = await Promise.all(
-      fileManager.files.map(async (file) => ({
-        ...file,
-        source: await FileManager.getSource(file),
-      })),
-    )
 
+    if (options.config.output.exportType) {
+      await pluginManager.fileManager.add(rootFile)
+    }
+
+    //TODO set extName here instead of the files, extName is private. All exports will have extName, it's up the the process to hide.override the name
+    files = await processFiles({
+      config: options.config,
+      dryRun: !options.config.output.write,
+      files: pluginManager.fileManager.files,
+      logger: pluginManager.logger,
+    })
+
+    await pluginManager.hookParallel({ hookName: 'buildEnd', message: `Build stopped for ${options.config.name}` })
+
+    pluginManager.fileManager.clear()
+  } catch (e) {
     return {
-      files,
+      files: [],
       pluginManager,
       error: e as Error,
     }
   }
 
-  const files = await Promise.all(
-    fileManager.files.map(async (file) => ({
-      ...file,
-      source: await FileManager.getSource(file),
-    })),
-  )
-
   return {
     files,
     pluginManager,

package/src/errors.ts

@@ -1,12 +1 @@
-/**
- * Behaves as an Error to log a warning in the console(still stops the execution)
- */
-export class Warning extends Error {
-  constructor(message?: string, options?: { cause: Error }) {
-    super(message, { cause: options?.cause })
-
-    this.name = 'Warning'
-  }
-}
-
 export class ValidationPluginError extends Error {}

package/src/index.ts

@@ -1,9 +1,8 @@
 export { build, build as default, safeBuild } from './build.ts'
 export { defineConfig, isInputPath } from './config.ts'
-export { Warning } from './errors.ts'
 export { FileManager } from './FileManager.ts'
 export type { FileMetaBase } from './FileManager.ts'
-export { Generator } from './Generator.ts'
+export { BaseGenerator } from './BaseGenerator.ts'
 export { PackageManager } from './PackageManager.ts'
 export { createPlugin } from './plugin.ts'
 export { PluginManager } from './PluginManager.ts'

package/src/logger.ts

@@ -3,16 +3,24 @@ import c, { createColors } from 'tinyrainbow'
 
 import { EventEmitter } from './utils/EventEmitter.ts'
 
-import type { ConsolaInstance } from 'consola'
-import type { Ora } from 'ora'
+import { resolve } from 'node:path'
+import { write } from '@kubb/fs'
+import { type ConsolaInstance, type LogLevel, createConsola } from 'consola'
 import type { Formatter } from 'tinyrainbow'
 
-//TODO replace with verbose flag and debug flag
-export const LogLevel = {
-  silent: 'silent',
-  info: 'info',
-  debug: 'debug',
-} as const
+type DebugEvent = { date: Date; logs: string[]; fileName?: string }
+
+type Events = {
+  start: [message: string]
+  success: [message: string]
+  error: [message: string, cause: Error]
+  warning: [message: string]
+  debug: [DebugEvent]
+  info: [message: string]
+  progress_start: [{ id: string; size: number; message?: string }]
+  progressed: [{ id: string; message?: string }]
+  progress_stop: [{ id: string }]
+}
 
 export const LogMapper = {
   silent: Number.NEGATIVE_INFINITY,
@@ -20,54 +28,65 @@ export const LogMapper = {
   debug: 4,
 } as const
 
-export type LogLevel = keyof typeof LogLevel
-
-type Events = {
-  start: [message: string]
-  end: [message: string]
-  error: [message: string, cause: Error]
-  warning: [message: string]
-  debug: [logs: string[]]
-}
 export type Logger = {
   /**
    * Optional config name to show in CLI output
    */
   name?: string
   logLevel: LogLevel
-  spinner?: Ora
   consola?: ConsolaInstance
   on: EventEmitter<Events>['on']
   emit: EventEmitter<Events>['emit']
+  writeLogs: () => Promise<string[]>
 }
 
 type Props = {
   name?: string
-  logLevel: LogLevel
-  spinner?: Ora
+  logLevel?: LogLevel
   consola?: ConsolaInstance
 }
 
-export function createLogger({ logLevel, name, spinner, consola }: Props): Logger {
+export function createLogger({ logLevel = 3, name, consola: _consola }: Props = {}): Logger {
   const events = new EventEmitter<Events>()
+  const startDate = Date.now()
+  const cachedLogs = new Set<DebugEvent>()
+
+  const consola =
+    _consola ||
+    createConsola({
+      level: logLevel,
+      formatOptions: {
+        colors: true,
+        date: true,
+        columns: 80,
+        compact: logLevel !== LogMapper.debug,
+      },
+    }).withTag(name ? randomCliColour(name) : '')
+
+  consola?.wrapConsole()
 
   events.on('start', (message) => {
-    if (spinner) {
-      spinner.start(message)
-    }
+    consola.start(message)
   })
 
-  events.on('end', (message) => {
-    if (spinner) {
-      spinner.suffixText = ''
-      spinner.succeed(message)
-    }
+  events.on('success', (message) => {
+    consola.success(message)
   })
 
   events.on('warning', (message) => {
-    if (spinner) {
-      spinner.warn(c.yellow(message))
+    consola.warn(c.yellow(message))
+  })
+
+  events.on('info', (message) => {
+    consola.info(c.yellow(message))
+  })
+
+  events.on('debug', (message) => {
+    if (message.logs.join('\n\n').length <= 100 && logLevel === LogMapper.debug) {
+      console.log(message.logs.join('\n\n'))
     }
+
+    cachedLogs.add(message)
   })
 
   events.on('error', (message, cause) => {
@@ -77,17 +96,40 @@ export function createLogger({ logLevel, name, spinner, consola }: Props): Logge
     throw error
   })
 
+  if (consola) {
+    consola.level = logLevel
+  }
+
   const logger: Logger = {
     name,
     logLevel,
-    spinner,
     consola,
-    on: (...args) => {
+    on(...args) {
       return events.on(...args)
     },
-    emit: (...args) => {
+    emit(...args) {
       return events.emit(...args)
     },
+    async writeLogs() {
+      const files: Record<string, string[]> = {}
+
+      cachedLogs.forEach((log) => {
+        const fileName = resolve(process.cwd(), '.kubb', log.fileName || `kubb-${startDate}.log`)
+
+        if (!files[fileName]) {
+          files[fileName] = []
+        }
+
+        files[fileName] = [...files[fileName], `[${log.date.toLocaleString()}]: ${log.logs.join('\n\n')}`]
+      })
+      await Promise.all(
+        Object.entries(files).map(async ([fileName, logs]) => {
+          return write(fileName, logs.join('\n'))
+        }),
+      )
+
+      return Object.keys(files)
+    },
   }
 
   return logger