@kubb/core 3.0.0-alpha.2 → 3.0.0-alpha.20

package/src/__snapshots__/grouped.json

@@ -0,0 +1,120 @@
+{
+  "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": [],
+                "meta": {}
+              },
+              "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": [],
+                "meta": {}
+              },
+              "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": [],
+                    "meta": {}
+                  },
+                  "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": [],
+                "meta": {}
+              },
+              "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": [],
+                "meta": {}
+              },
+              "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": [],
+            "meta": {}
+          },
+          "path": "src/test.ts"
+        }
+      ]
+    }
+  ]
+}

package/src/__snapshots__/ordered.json

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

package/src/build.ts

@@ -1,14 +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 { 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 { PluginContext, PluginParameter } from './types.ts'
+import type { Output, PluginContext } from './types.ts'
 
 type BuildOptions = {
   config: PluginContext['config']
@@ -28,8 +29,7 @@ type BuildOutput = {
 }
 
 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) {
@@ -37,157 +37,122 @@ 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
-
-    const source: string | null = await FileManager.getSource(file)
-
-    if (source) {
-      if (config.output.write || config.output.write === undefined) {
-        await pluginManager.fileManager.write(path, source, { sanity: false })
-      }
-    }
-
-    return {
-      ...file,
-      source: source || '',
-    }
-  }
-
-  const pluginManager = new PluginManager(config, { logger, task })
-
-  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',
+    })
+
+    // 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)
     })
 
-    await pluginManager.hookParallel({ hookName: 'buildEnd' })
+    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.key === meta?.pluginKey
+              })
+              const options = (plugin?.options as { output?: Output }) ?? {}
+
+              if (options.output?.exportType === false) {
+                return undefined
+              }
+
+              if (FileManager.getMode(options.output?.path) === 'single') {
+                return undefined
+              }
+              return {
+                name: options.output?.exportType === 'barrel' ? undefined : [source.name],
+                path: getRelativePath(rootPath, file.path),
+                isTypeOnly: source.isTypeOnly,
+              } as KubbFile.Export
+            })
+            .filter(Boolean)
+        })
+        .filter(Boolean),
+      sources: [],
+      meta: {},
+    }
 
-    if (logger.logLevel === LogLevel.info) {
-      logger.emit('end', '💾 Writing completed')
+    if (options.config.output.exportType) {
+      await pluginManager.fileManager.add(rootFile)
     }
-  } catch (e) {
-    const files = await Promise.all(
-      fileManager.files.map(async (file) => ({
-        ...file,
-        source: await FileManager.getSource(file),
-      })),
-    )
 
+    //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/config.ts

@@ -45,5 +45,5 @@ export function defineConfig(
 }
 
 export function isInputPath(result: Config | undefined): result is Config<InputPath> {
-  return !!result && 'path' in (result as any)
+  return !!result && 'path' in (result?.input as any)
 }

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 { FileManager, getSource } 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

package/src/plugin.ts

@@ -1,7 +1,5 @@
 import path from 'node:path'
 
-import { createPluginCache } from './utils/cache.ts'
-
 import type { FileManager } from './FileManager.ts'
 import type { PluginManager } from './PluginManager.ts'
 import type { Plugin, PluginContext, PluginFactoryOptions, UserPluginWithLifeCycle } from './types.ts'
@@ -46,7 +44,7 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
           return options.getPlugins()
         },
         get plugin() {
-          // see pluginManger.#execute where we override with `.call` the this with the correct plugin
+          // see pluginManger.#execute where we override with `.call` the context with the correct plugin
           return options.plugin as NonNullable<Options['plugin']>
         },
         logger,
@@ -63,11 +61,10 @@ export const pluginCore = createPlugin<PluginCore>((options) => {
         },
         resolvePath,
         resolveName,
-        cache: createPluginCache(),
       }
     },
     resolvePath(baseName) {
-      const root = path.resolve(this.config.root, this.config.output.path)
+      const root = path.resolve(options.config.root, options.config.output.path)
 
       return path.resolve(root, baseName)
     },