@kubb/core 1.0.0-beta.9 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/core",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.1",
   "description": "Generator core",
   "repository": {
     "type": "git",
@@ -42,23 +42,21 @@
   "dependencies": {
     "change-case": "^4.1.2",
     "directory-tree": "^3.5.1",
-    "lodash.uniq": "^4.5.0",
-    "rimraf": "^3.0.2",
-    "uuid": "^9.0.0"
+    "rimraf": "^5.0.1",
+    "@kubb/ts-codegen": "1.0.1"
   },
   "devDependencies": {
-    "@types/lodash.uniq": "^4.5.7",
-    "@types/rimraf": "^3.0.2",
-    "@types/uuid": "^9.0.1",
     "tsup": "^6.7.0",
-    "typescript": "^5.0.3"
+    "ora": "^6.3.1",
+    "typescript": "^5.1.3"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "engines": {
-    "node": "^12.17.0 || ^14.13 || >=16.0.0"
+    "node": ">=16",
+    "pnpm": ">=8"
   },
   "scripts": {
     "build": "tsup",
@@ -69,6 +67,6 @@
     "test": "vitest --passWithNoTests",
     "upgrade": "ncu -u",
     "upgrade:local": "ncu --interactive --doctor",
-    "typecheck": "tsc -p ./tsconfig.json --noEmit"
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
   }
 }

package/src/build.ts

@@ -1,33 +1,17 @@
 /* eslint-disable no-async-promise-executor */
-import pathParser from 'path'
+import { PluginManager } from './managers/pluginManager/index.ts'
+import { clean, read } from './utils/index.ts'
+import { getFileSource } from './managers/fileManager/index.ts'
 
-import { isURL } from './utils/isURL'
-import { PluginManager } from './managers/pluginManager'
-import { clean, read } from './utils'
-import { getFileSource } from './managers/fileManager'
-
-import type { FileManager, File } from './managers/fileManager'
-import type { QueueTask } from './utils'
-import type { PluginContext, TransformResult, LogLevel, KubbPlugin } from './types'
-
-type BuildOutput = {
-  files: FileManager['files']
-}
-
-// Same type as ora
-type Spinner = {
-  start: (text?: string) => Spinner
-  succeed: (text: string) => Spinner
-  fail: (text?: string) => Spinner
-  stopAndPersist: (options: { text: string }) => Spinner
-  render: () => Spinner
-  text: string
-  info: (text: string) => Spinner
-}
+import type { OnExecute } from './managers/pluginManager/index.ts'
+import type { File } from './managers/fileManager/index.ts'
+import type { QueueTask } from './utils/index.ts'
+import type { PluginContext, TransformResult, LogLevel, KubbPlugin, BuildOutput } from './types.ts'
+import type { Ora } from 'ora'
 
 export type Logger = {
   log: (message: string, logLevel: LogLevel) => void
-  spinner?: Spinner
+  spinner?: Ora
 }
 type BuildOptions = {
   config: PluginContext['config']
@@ -46,9 +30,15 @@ async function transformReducer(
   return result
 }
 
-async function buildImplementation(options: BuildOptions, done: (output: BuildOutput) => void) {
+export async function build(options: BuildOptions): Promise<BuildOutput> {
   const { config, logger } = options
 
+  try {
+    await read(config.input.path)
+  } catch (e: any) {
+    throw new Error('Cannot read file defined in `input.path` or set with --input in the CLI of your Kubb config', { cause: e })
+  }
+
   if (config.output.clean) {
     await clean(config.output.path)
   }
@@ -82,7 +72,19 @@ async function buildImplementation(options: BuildOptions, done: (output: BuildOu
     }
   }
 
-  const pluginManager = new PluginManager(config, { logger, task: queueTask as QueueTask })
+  const onExecute: OnExecute = (executer) => {
+    if (!executer) {
+      return
+    }
+
+    const { strategy, hookName, plugin } = executer
+
+    if (config.logLevel === 'info' && logger?.spinner) {
+      logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} \n`
+    }
+  }
+
+  const pluginManager = new PluginManager(config, { task: queueTask as QueueTask, onExecute })
   const { plugins, fileManager } = pluginManager
 
   await pluginManager.hookParallel<'validate', true>({
@@ -96,25 +98,6 @@ async function buildImplementation(options: BuildOptions, done: (output: BuildOu
   })
 
   await pluginManager.hookParallel({ hookName: 'buildEnd' })
-  setTimeout(() => {
-    done({ files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) })
-  }, 500)
-
-  pluginManager.fileManager.add({
-    path: isURL(config.input.path) ? config.input.path : pathParser.resolve(config.root, config.input.path),
-    fileName: isURL(config.input.path) ? 'input' : config.input.path,
-    source: isURL(config.input.path) ? config.input.path : await read(pathParser.resolve(config.root, config.input.path)),
-  })
-}
-
-export type KubbBuild = (options: BuildOptions) => Promise<BuildOutput>
 
-export function build(options: BuildOptions): Promise<BuildOutput> {
-  return new Promise(async (resolve, reject) => {
-    try {
-      await buildImplementation(options, resolve)
-    } catch (e) {
-      reject(e)
-    }
-  })
+  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })), pluginManager }
 }

package/src/config.ts

@@ -1,7 +1,7 @@
-import type { MaybePromise, KubbUserConfig, CLIOptions } from './types'
+import type { MaybePromise, KubbUserConfig, CLIOptions } from './types.ts'
 
 /**
- * Type helper to make it easier to use kubb.config.ts
+ * Type helper to make it easier to use kubb.config.js
  * accepts a direct {@link KubbConfig} object, or a function that returns it.
  * The function receives a {@link ConfigEnv} object that exposes two properties:
  */

package/src/generators/SchemaGenerator.ts

@@ -1,4 +1,4 @@
-import { Generator } from './Generator'
+import { Generator } from './Generator.ts'
 /**
  * Abstract class that contains the building blocks for plugins to create their own SchemaGenerator
  */

package/src/generators/index.ts

@@ -1,2 +1,2 @@
-export * from './SchemaGenerator'
-export * from './Generator'
+export * from './SchemaGenerator.ts'
+export * from './Generator.ts'

package/src/index.ts

@@ -1,12 +1,13 @@
 /* eslint-disable @typescript-eslint/no-empty-interface */
-import { build } from './build'
+import { build } from './build.ts'
 
-export * from './config'
-export * from './build'
-export { CorePluginOptions, createPlugin, name } from './plugin'
-export * from './utils'
-export * from './types'
-export * from './managers'
-export * from './generators'
+export * from './config.ts'
+export * from './build.ts'
+export * from './types.ts'
+export { CorePluginOptions, createPlugin, name } from './plugin.ts'
+
+export * from './utils/index.ts'
+export * from './managers/index.ts'
+export * from './generators/index.ts'
 
 export default build

package/src/managers/fileManager/FileManager.ts

@@ -1,9 +1,9 @@
-import { v4 as uuidv4 } from 'uuid'
+import crypto from 'node:crypto'
 
-import { write, read } from '../../utils'
+import { write, read } from '../../utils/index.ts'
 
-import type { QueueTask, Queue } from '../../utils'
-import type { CacheStore, UUID, Status, File } from './types'
+import type { QueueTask, Queue } from '../../utils/index.ts'
+import type { CacheStore, UUID, Status, File } from './types.ts'
 
 export class FileManager {
   private cache: Map<CacheStore['id'], CacheStore> = new Map()
@@ -23,7 +23,7 @@ export class FileManager {
     return this.cache.get(id)
   }
 
-  private getCacheByPath(path: string | undefined): CacheStore | undefined {
+  getCacheByPath(path: string | undefined): CacheStore | undefined {
     let cache
 
     this.cache.forEach((item) => {
@@ -44,7 +44,7 @@ export class FileManager {
   }
 
   async add(file: File) {
-    const cacheItem = { id: uuidv4(), file, status: 'new' as Status }
+    const cacheItem = { id: crypto.randomUUID(), file, status: 'new' as Status }
 
     this.cache.set(cacheItem.id, cacheItem)
 
@@ -58,14 +58,27 @@ export class FileManager {
   }
 
   addOrAppend(file: File) {
+    if (!file.path.endsWith(file.fileName)) {
+      // console.warn(`Path ${file.path}(file.path) should end with the fileName ${file.fileName}(file.filename)`)
+    }
+
     const previousCache = this.getCacheByPath(file.path)
 
     if (previousCache) {
+      // empty source will also return true when using includes
+      const sourceAlreadyExists = file.source && previousCache.file.source.includes(file.source)
+
+      if (sourceAlreadyExists) {
+        return Promise.resolve(file)
+      }
+
       this.cache.delete(previousCache.id)
+
       return this.add({
         ...file,
         source: `${previousCache.file.source}\n${file.source}`,
         imports: [...(previousCache.file.imports || []), ...(file.imports || [])],
+        exports: [...(previousCache.file.exports || []), ...(file.exports || [])],
       })
     }
     return this.add(file)

package/src/managers/fileManager/index.ts

@@ -1,4 +1,3 @@
-export * from './FileManager'
-export * from './types'
-export * from './TreeNode'
-export * from './utils'
+export * from './FileManager.ts'
+export * from './types.ts'
+export * from './utils.ts'

package/src/managers/fileManager/types.ts

@@ -1,9 +1,16 @@
 type Import = {
-  name: string | string[] | readonly string[]
+  name: string | string[]
   path: string
   isTypeOnly?: boolean
 }
 
+type Export = {
+  name?: string | string[]
+  path: string
+  isTypeOnly?: boolean
+  asAlias?: boolean
+}
+
 export type File = {
   /**
    * Name to be used to dynamicly create the fileName(based on input.path)
@@ -15,6 +22,15 @@ export type File = {
   path: string
   source: string
   imports?: Import[]
+  exports?: Export[]
+  /**
+   * This will call fileManager.add instead of fileManager.addOrAppend, adding the source when the files already exists
+   * @default `false`
+   */
+  override?: boolean
+  meta?: {
+    pluginName?: string
+  }
 }
 
 export type UUID = string

package/src/managers/fileManager/utils.ts

@@ -1,6 +1,76 @@
-import uniq from 'lodash.uniq'
+import pathParser from 'node:path'
 
-import type { File } from './types'
+import { createImportDeclaration, createExportDeclaration, print } from '@kubb/ts-codegen'
+
+import { TreeNode } from '../../utils/index.ts'
+
+import type { PathMode, TreeNodeOptions } from '../../utils/index.ts'
+import type { Path } from '../../types.ts'
+import type ts from 'typescript'
+import type { File } from './types.ts'
+
+export function writeIndexes(root: string, options: TreeNodeOptions) {
+  const tree = TreeNode.build<{ type: PathMode; path: Path; name: string }>(root, { extensions: /\.ts/, ...options })
+
+  if (!tree) {
+    return undefined
+  }
+
+  const fileReducer = (files: File[], item: typeof tree) => {
+    if (!item.children) {
+      return []
+    }
+
+    if (item.children?.length > 1) {
+      const path = pathParser.resolve(item.data.path, 'index.ts')
+      const exports = item.children
+        .map((file) => {
+          if (!file) {
+            return undefined
+          }
+
+          const importPath: string = file.data.type === 'directory' ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, '')}`
+
+          // TODO weird hacky fix
+          if (importPath.includes('index') && path.includes('index')) {
+            return undefined
+          }
+
+          return { path: importPath }
+        })
+        .filter(Boolean) as File['exports']
+
+      files.push({
+        path,
+        fileName: 'index.ts',
+        source: '',
+        exports,
+      })
+    } else {
+      item.children?.forEach((child) => {
+        const path = pathParser.resolve(item.data.path, 'index.ts')
+        const importPath = child.data.type === 'directory' ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, '')}`
+
+        files.push({
+          path,
+          fileName: 'index.ts',
+          source: '',
+          exports: [{ path: importPath }],
+        })
+      })
+    }
+
+    item.children.forEach((childItem) => {
+      fileReducer(files, childItem)
+    })
+
+    return files
+  }
+
+  const files = fileReducer([], tree)
+
+  return files
+}
 
 export function combineFiles(files: Array<File | null>) {
   return files.filter(Boolean).reduce((acc, curr: File | null) => {
@@ -15,6 +85,7 @@ export function combineFiles(files: Array<File | null>) {
         ...curr,
         source: `${prev.source}\n${curr.source}`,
         imports: [...(prev.imports || []), ...(curr.imports || [])],
+        exports: [...(prev.exports || []), ...(curr.exports || [])],
       }
     } else {
       acc.push(curr)
@@ -25,18 +96,21 @@ export function combineFiles(files: Array<File | null>) {
 }
 
 export function getFileSource(file: File) {
+  let { source } = file
+
   // TODO make generic check
   if (!file.fileName.endsWith('.ts')) {
     return file.source
   }
   const imports: File['imports'] = []
+  const exports: File['exports'] = []
 
   file.imports?.forEach((curr) => {
     const exists = imports.find((imp) => imp.path === curr.path)
     if (!exists) {
       imports.push({
         ...curr,
-        name: Array.isArray(curr.name) ? uniq(curr.name) : curr.name,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name,
       })
     }
 
@@ -46,22 +120,48 @@ export function getFileSource(file: File) {
 
     if (exists && Array.isArray(exists.name)) {
       if (Array.isArray(curr.name)) {
-        exists.name = uniq([...exists.name, ...curr.name])
+        exists.name = [...new Set([...exists.name, ...curr.name])]
       }
     }
   })
 
-  const importSource = imports.reduce((prev, curr) => {
-    if (Array.isArray(curr.name)) {
-      return `${prev}\nimport ${curr.isTypeOnly ? 'type ' : ''}{ ${curr.name.join(', ')} } from "${curr.path}";`
+  file.exports?.forEach((curr) => {
+    const exists = exports.find((imp) => imp.path === curr.path)
+    if (!exists) {
+      exports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name,
+      })
     }
 
-    return `${prev}\nimport ${curr.isTypeOnly ? 'type ' : ''}${curr.name} from "${curr.path}";`
-  }, '')
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name && exists.asAlias === curr.asAlias) {
+      exports.push(curr)
+    }
+
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [...new Set([...exists.name, ...curr.name])]
+      }
+    }
+  })
+
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })]
+  }, [] as ts.ImportDeclaration[])
+  const importSource = print(importNodes)
+
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })]
+  }, [] as ts.ExportDeclaration[])
+  const exportSource = print(exportNodes)
 
   if (importSource) {
-    return `${importSource}\n${file.source}`
+    source = `${importSource}\n${source}`
+  }
+
+  if (exportSource) {
+    source = `${exportSource}\n${source}`
   }
 
-  return file.source
+  return source
 }

package/src/managers/index.ts

@@ -1,2 +1,2 @@
-export * from './fileManager'
-export * from './pluginManager'
+export * from './fileManager/index.ts'
+export * from './pluginManager/index.ts'

package/src/managers/pluginManager/ParallelPluginError.ts

@@ -0,0 +1,15 @@
+import type { PluginError } from './PluginError.ts'
+import type { PluginManager } from './PluginManager'
+
+export class ParallelPluginError extends Error {
+  public errors: PluginError[]
+
+  public pluginManager: PluginManager
+
+  constructor(message: string, options: { cause?: Error; errors: PluginError[]; pluginManager: PluginManager }) {
+    super(message, { cause: options.cause })
+
+    this.errors = options.errors
+    this.pluginManager = options.pluginManager
+  }
+}

package/src/managers/pluginManager/PluginError.ts

@@ -0,0 +1,11 @@
+import type { PluginManager } from './PluginManager'
+
+export class PluginError extends Error {
+  public pluginManager: PluginManager
+
+  constructor(message: string, options: { cause?: Error; pluginManager: PluginManager }) {
+    super(message, { cause: options.cause })
+
+    this.pluginManager = options.pluginManager
+  }
+}