@kubb/core 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,14 +1,33 @@
 import { createRequire } from 'module';
-import pathParser2 from 'path';
-import { promises } from 'fs';
-import rimraf from 'rimraf';
+import pathParser2 from 'node:path';
+import { promises } from 'node:fs';
+import { rimraf } from 'rimraf';
 import dirTree from 'directory-tree';
-import { v4 } from 'uuid';
-import uniq from 'lodash.uniq';
+import crypto from 'node:crypto';
 import { createImportDeclaration, print, createExportDeclaration } from '@kubb/ts-codegen';
 
 createRequire(import.meta.url);
 
+// src/managers/pluginManager/PluginError.ts
+var PluginError = class extends Error {
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.pluginManager = options.pluginManager;
+  }
+};
+
+// src/managers/pluginManager/ParallelPluginError.ts
+var ParallelPluginError = class extends Error {
+  errors;
+  pluginManager;
+  constructor(message, options) {
+    super(message, { cause: options.cause });
+    this.errors = options.errors;
+    this.pluginManager = options.pluginManager;
+  }
+};
+
 // src/utils/isPromise.ts
 function isPromise(result) {
   return typeof result?.then === "function";
@@ -204,15 +223,7 @@ function renderTemplate(template, data = void 0) {
   });
 }
 async function clean(path) {
-  return new Promise((resolve, reject) => {
-    rimraf(path, (err) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(true);
-      }
-    });
-  });
+  return rimraf(path);
 }
 var TreeNode = class {
   data;
@@ -381,12 +392,28 @@ var reservedWords = [
   "valueOf"
 ];
 function transformReservedWord(word) {
-  if (reservedWords.includes(word)) {
+  if (word && reservedWords.includes(word)) {
     return `_${word}`;
   }
   return word;
 }
 
+// src/utils/getStackTrace.ts
+function getStackTrace(belowFn) {
+  const oldLimit = Error.stackTraceLimit;
+  Error.stackTraceLimit = Infinity;
+  const dummyObject = {};
+  const v8Handler = Error.prepareStackTrace;
+  Error.prepareStackTrace = function prepareStackTrace(dummyObject2, v8StackTrace2) {
+    return v8StackTrace2;
+  };
+  Error.captureStackTrace(dummyObject, belowFn || getStackTrace);
+  const v8StackTrace = dummyObject.stack;
+  Error.prepareStackTrace = v8Handler;
+  Error.stackTraceLimit = oldLimit;
+  return v8StackTrace;
+}
+
 // src/plugin.ts
 function createPlugin(factory) {
   return (options) => {
@@ -411,7 +438,30 @@ var definePlugin = createPlugin((options) => {
     },
     fileManager,
     async addFile(...files) {
-      return Promise.all(files.map((file) => file.override ? fileManager.add(file) : fileManager.addOrAppend(file)));
+      const trace = getStackTrace();
+      const plugins = options.config.plugins?.filter((plugin) => trace[1].getFileName()?.includes(plugin.name)).sort((a, b) => {
+        if (a.name.length < b.name.length)
+          return 1;
+        if (a.name.length > b.name.length)
+          return -1;
+        return 0;
+      });
+      const pluginName = plugins?.[0].name;
+      return Promise.all(
+        files.map((file) => {
+          const fileWithMeta = {
+            ...file,
+            meta: {
+              ...file.meta || {},
+              pluginName
+            }
+          };
+          if (file.override) {
+            return fileManager.add(fileWithMeta);
+          }
+          return fileManager.addOrAppend(fileWithMeta);
+        })
+      );
     },
     resolvePath,
     resolveName: (params) => {
@@ -464,7 +514,7 @@ var FileManager = class {
     return files;
   }
   async add(file) {
-    const cacheItem = { id: v4(), file, status: "new" };
+    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
     this.cache.set(cacheItem.id, cacheItem);
     if (this.queue) {
       await this.queue.run(async () => {
@@ -518,133 +568,6 @@ ${file.source}`,
     return read(...params);
   }
 };
-function writeIndexes(root, options) {
-  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
-  if (!tree) {
-    return void 0;
-  }
-  const fileReducer = (files2, item) => {
-    if (!item.children) {
-      return [];
-    }
-    if (item.children?.length > 1) {
-      const path = pathParser2.resolve(item.data.path, "index.ts");
-      const exports = item.children.map((file) => {
-        if (!file) {
-          return void 0;
-        }
-        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
-        if (importPath.includes("index") && path.includes("index")) {
-          return void 0;
-        }
-        return { path: importPath };
-      }).filter(Boolean);
-      files2.push({
-        path,
-        fileName: "index.ts",
-        source: "",
-        exports
-      });
-    } else {
-      item.children?.forEach((child) => {
-        const path = pathParser2.resolve(item.data.path, "index.ts");
-        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
-        files2.push({
-          path,
-          fileName: "index.ts",
-          source: "",
-          exports: [{ path: importPath }]
-        });
-      });
-    }
-    item.children.forEach((childItem) => {
-      fileReducer(files2, childItem);
-    });
-    return files2;
-  };
-  const files = fileReducer([], tree);
-  return files;
-}
-function combineFiles(files) {
-  return files.filter(Boolean).reduce((acc, curr) => {
-    if (!curr) {
-      return acc;
-    }
-    const prevIndex = acc.findIndex((item) => item.path === curr.path);
-    if (prevIndex !== -1) {
-      const prev = acc[prevIndex];
-      acc[prevIndex] = {
-        ...curr,
-        source: `${prev.source}
-${curr.source}`,
-        imports: [...prev.imports || [], ...curr.imports || []],
-        exports: [...prev.exports || [], ...curr.exports || []]
-      };
-    } else {
-      acc.push(curr);
-    }
-    return acc;
-  }, []);
-}
-function getFileSource(file) {
-  let { source } = file;
-  if (!file.fileName.endsWith(".ts")) {
-    return file.source;
-  }
-  const imports = [];
-  const 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
-      });
-    }
-    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
-      imports.push(curr);
-    }
-    if (exists && Array.isArray(exists.name)) {
-      if (Array.isArray(curr.name)) {
-        exists.name = uniq([...exists.name, ...curr.name]);
-      }
-    }
-  });
-  file.exports?.forEach((curr) => {
-    const exists = exports.find((imp) => imp.path === curr.path);
-    if (!exists) {
-      exports.push({
-        ...curr,
-        name: Array.isArray(curr.name) ? uniq(curr.name) : curr.name
-      });
-    }
-    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 = uniq([...exists.name, ...curr.name]);
-      }
-    }
-  });
-  const importNodes = imports.reduce((prev, curr) => {
-    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
-  }, []);
-  const importSource = print(importNodes);
-  const exportNodes = exports.reduce((prev, curr) => {
-    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
-  }, []);
-  const exportSource = print(exportNodes);
-  if (importSource) {
-    source = `${importSource}
-${source}`;
-  }
-  if (exportSource) {
-    source = `${exportSource}
-${source}`;
-  }
-  return source;
-}
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -661,13 +584,13 @@ var hooks = Object.keys(hookNames);
 var PluginManager = class {
   plugins;
   fileManager;
-  logger;
-  config;
+  onExecute;
   core;
   queue;
+  executer;
+  executed = [];
   constructor(config, options) {
-    this.logger = options.logger;
-    this.config = config;
+    this.onExecute = options.onExecute;
     this.queue = new Queue(10);
     this.fileManager = new FileManager({ task: options.task, queue: this.queue });
     this.core = definePlugin({
@@ -675,10 +598,14 @@ var PluginManager = class {
       fileManager: this.fileManager,
       load: this.load,
       resolvePath: this.resolvePath,
-      resolveName: this.resolveName
+      resolveName: this.resolveName,
+      getExecuter: this.getExecuter.bind(this)
     });
     this.plugins = [this.core, ...config.plugins || []];
   }
+  getExecuter() {
+    return this.executer;
+  }
   resolvePath = (params) => {
     if (params.pluginName) {
       return this.hookForPluginSync({
@@ -721,7 +648,7 @@ var PluginManager = class {
     parameters
   }) {
     const plugin = this.getPlugin(hookName, pluginName);
-    return this.run({
+    return this.execute({
       strategy: "hookFirst",
       hookName,
       parameters,
@@ -734,7 +661,7 @@ var PluginManager = class {
     parameters
   }) {
     const plugin = this.getPlugin(hookName, pluginName);
-    return this.runSync({
+    return this.executeSync({
       strategy: "hookFirst",
       hookName,
       parameters,
@@ -757,7 +684,7 @@ var PluginManager = class {
       promise = promise.then((result) => {
         if (result != null)
           return result;
-        return this.run({
+        return this.execute({
           strategy: "hookFirst",
           hookName,
           parameters,
@@ -780,7 +707,7 @@ var PluginManager = class {
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      result = this.runSync({
+      result = this.executeSync({
         strategy: "hookFirst",
         hookName,
         parameters,
@@ -802,18 +729,25 @@ var PluginManager = class {
       if (plugin[hookName]?.sequential) {
         await Promise.all(parallelPromises);
         parallelPromises.length = 0;
-        await this.run({
+        await this.execute({
           strategy: "hookParallel",
           hookName,
           parameters,
           plugin
         });
       } else {
-        const promise = this.run({ strategy: "hookParallel", hookName, parameters, plugin });
-        parallelPromises.push(promise);
+        const promise = this.execute({ strategy: "hookParallel", hookName, parameters, plugin });
+        if (promise) {
+          parallelPromises.push(promise);
+        }
       }
     }
-    return Promise.all(parallelPromises);
+    const results = await Promise.allSettled(parallelPromises);
+    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    if (errors.length) {
+      throw new ParallelPluginError("Error", { errors, pluginManager: this });
+    }
+    return results.filter((result) => result.status === "fulfilled").map((result) => result.value);
   }
   // chains, reduces returned value, handling the reduced value as the first hook argument
   hookReduceArg0({
@@ -824,14 +758,15 @@ var PluginManager = class {
     const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(
-        (argument02) => this.run({
+      promise = promise.then((argument02) => {
+        const value = this.execute({
           strategy: "hookReduceArg0",
           hookName,
           parameters: [argument02, ...rest],
           plugin
-        }).then((result) => reduce.call(this.core.api, argument02, result, plugin))
-      );
+        });
+        return value;
+      }).then((result) => reduce.call(this.core.api, argument0, result, plugin));
     }
     return promise;
   }
@@ -840,7 +775,7 @@ var PluginManager = class {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(
-        () => this.run({
+        () => this.execute({
           strategy: "hookSeq",
           hookName,
           parameters,
@@ -858,13 +793,16 @@ var PluginManager = class {
     const plugins = [...this.plugins];
     const pluginByPluginName = plugins.find((item) => item.name === pluginName && item[hookName]);
     if (!pluginByPluginName) {
-      if (this.config.logLevel === "warn" && this.logger?.spinner) {
-        this.logger.spinner.info(`Plugin hook with ${hookName} not found for plugin ${pluginName}`);
-      }
       return this.core;
     }
     return pluginByPluginName;
   }
+  addExecuter(executer) {
+    this.onExecute?.call(this, executer);
+    if (executer) {
+      this.executed.push(executer);
+    }
+  }
   /**
    * Run an async plugin hook and return the result.
    * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
@@ -872,36 +810,42 @@ var PluginManager = class {
    * @param plugin The actual pluginObject to run.
    */
   // Implementation signature
-  run({
+  execute({
     strategy,
     hookName,
     parameters,
     plugin
   }) {
     const hook = plugin[hookName];
+    if (!hook) {
+      return null;
+    }
     return Promise.resolve().then(() => {
-      if (typeof hook !== "function") {
-        return hook;
-      }
-      if (this.config.logLevel === "info" && this.logger?.spinner) {
-        this.logger.spinner.text = `[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`;
-      }
-      const hookResult = hook.apply(this.core.api, parameters);
-      if (!hookResult?.then) {
-        if (this.config.logLevel === "info" && this.logger?.spinner) {
-          this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`);
+      this.executer = {
+        strategy,
+        hookName,
+        plugin
+      };
+      if (typeof hook === "function") {
+        const hookResult = hook.apply(this.core.api, parameters);
+        if (isPromise(hookResult)) {
+          return Promise.resolve(hookResult).then((result) => {
+            this.addExecuter({
+              strategy,
+              hookName,
+              plugin
+            });
+            return result;
+          });
         }
         return hookResult;
       }
-      return Promise.resolve(hookResult).then((result) => {
-        if (this.config.logLevel === "info" && this.logger?.spinner) {
-          this.logger.spinner.succeed(`[${strategy}] ${hookName}: Excecuting task for plugin ${plugin.name} 
-`);
-        }
-        return result;
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin
       });
+      return hook;
     }).catch((e) => {
       this.catcher(e, plugin, hookName);
     });
@@ -913,18 +857,37 @@ var PluginManager = class {
    * @param plugin The acutal plugin
    * @param replaceContext When passed, the plugin context can be overridden.
    */
-  runSync({
+  executeSync({
     strategy,
     hookName,
     parameters,
     plugin
   }) {
     const hook = plugin[hookName];
+    if (!hook) {
+      return null;
+    }
     try {
-      if (typeof hook !== "function") {
-        return hook;
+      this.executer = {
+        strategy,
+        hookName,
+        plugin
+      };
+      if (typeof hook === "function") {
+        const fn = hook.apply(this.core.api, parameters);
+        this.addExecuter({
+          strategy,
+          hookName,
+          plugin
+        });
+        return fn;
       }
-      return hook.apply(this.core.api, parameters);
+      this.addExecuter({
+        strategy,
+        hookName,
+        plugin
+      });
+      return hook;
     } catch (e) {
       this.catcher(e, plugin, hookName);
       return null;
@@ -933,7 +896,7 @@ var PluginManager = class {
   catcher(e, plugin, hookName) {
     const text = `${e.message} (plugin: ${plugin.name}, hook: ${hookName})
 `;
-    throw new Error(text, { cause: e });
+    throw new PluginError(text, { cause: e, pluginManager: this });
   }
 };
 function noReturn() {
@@ -957,6 +920,133 @@ function validatePlugins(plugins, dependedPluginNames) {
   });
   return true;
 }
+function writeIndexes(root, options) {
+  const tree = TreeNode.build(root, { extensions: /\.ts/, ...options });
+  if (!tree) {
+    return void 0;
+  }
+  const fileReducer = (files2, item) => {
+    if (!item.children) {
+      return [];
+    }
+    if (item.children?.length > 1) {
+      const path = pathParser2.resolve(item.data.path, "index.ts");
+      const exports = item.children.map((file) => {
+        if (!file) {
+          return void 0;
+        }
+        const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+        if (importPath.includes("index") && path.includes("index")) {
+          return void 0;
+        }
+        return { path: importPath };
+      }).filter(Boolean);
+      files2.push({
+        path,
+        fileName: "index.ts",
+        source: "",
+        exports
+      });
+    } else {
+      item.children?.forEach((child) => {
+        const path = pathParser2.resolve(item.data.path, "index.ts");
+        const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
+        files2.push({
+          path,
+          fileName: "index.ts",
+          source: "",
+          exports: [{ path: importPath }]
+        });
+      });
+    }
+    item.children.forEach((childItem) => {
+      fileReducer(files2, childItem);
+    });
+    return files2;
+  };
+  const files = fileReducer([], tree);
+  return files;
+}
+function combineFiles(files) {
+  return files.filter(Boolean).reduce((acc, curr) => {
+    if (!curr) {
+      return acc;
+    }
+    const prevIndex = acc.findIndex((item) => item.path === curr.path);
+    if (prevIndex !== -1) {
+      const prev = acc[prevIndex];
+      acc[prevIndex] = {
+        ...curr,
+        source: `${prev.source}
+${curr.source}`,
+        imports: [...prev.imports || [], ...curr.imports || []],
+        exports: [...prev.exports || [], ...curr.exports || []]
+      };
+    } else {
+      acc.push(curr);
+    }
+    return acc;
+  }, []);
+}
+function getFileSource(file) {
+  let { source } = file;
+  if (!file.fileName.endsWith(".ts")) {
+    return file.source;
+  }
+  const imports = [];
+  const exports = [];
+  file.imports?.forEach((curr) => {
+    const exists = imports.find((imp) => imp.path === curr.path);
+    if (!exists) {
+      imports.push({
+        ...curr,
+        name: Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name
+      });
+    }
+    if (exists && !Array.isArray(exists.name) && exists.name !== curr.name) {
+      imports.push(curr);
+    }
+    if (exists && Array.isArray(exists.name)) {
+      if (Array.isArray(curr.name)) {
+        exists.name = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  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
+      });
+    }
+    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 = [.../* @__PURE__ */ new Set([...exists.name, ...curr.name])];
+      }
+    }
+  });
+  const importNodes = imports.reduce((prev, curr) => {
+    return [...prev, createImportDeclaration({ name: curr.name, path: curr.path, isTypeOnly: curr.isTypeOnly })];
+  }, []);
+  const importSource = print(importNodes);
+  const exportNodes = exports.reduce((prev, curr) => {
+    return [...prev, createExportDeclaration({ name: curr.name, path: curr.path, asAlias: curr.asAlias })];
+  }, []);
+  const exportSource = print(exportNodes);
+  if (importSource) {
+    source = `${importSource}
+${source}`;
+  }
+  if (exportSource) {
+    source = `${exportSource}
+${source}`;
+  }
+  return source;
+}
 
 // src/build.ts
 async function transformReducer(_previousCode, result, _plugin) {
@@ -965,8 +1055,15 @@ async function transformReducer(_previousCode, result, _plugin) {
   }
   return result;
 }
-async function buildImplementation(options) {
+async function build(options) {
   const { config, logger } = options;
+  try {
+    if (!isURL(config.input.path)) {
+      await read(config.input.path);
+    }
+  } catch (e) {
+    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);
   }
@@ -994,7 +1091,17 @@ async function buildImplementation(options) {
       }
     }
   };
-  const pluginManager = new PluginManager(config, { logger, task: queueTask });
+  const 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} 
+`;
+    }
+  };
+  const pluginManager = new PluginManager(config, { task: queueTask, onExecute });
   const { plugins, fileManager } = pluginManager;
   await pluginManager.hookParallel({
     hookName: "validate",
@@ -1005,19 +1112,7 @@ async function buildImplementation(options) {
     parameters: [config]
   });
   await pluginManager.hookParallel({ hookName: "buildEnd" });
-  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) };
-}
-function build(options) {
-  return new Promise(async (resolve, reject) => {
-    try {
-      const output = await buildImplementation(options);
-      setTimeout(() => {
-        resolve(output);
-      }, 500);
-    } catch (e) {
-      reject(e);
-    }
-  });
+  return { files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })), pluginManager };
 }
 
 // src/config.ts
@@ -1047,6 +1142,4 @@ var SchemaGenerator = class extends Generator {
 // src/index.ts
 var src_default = build;
 
-export { FileManager, Generator, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map
+export { FileManager, Generator, ParallelPluginError, PluginError, PluginManager, Queue, SchemaGenerator, TreeNode, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, src_default as default, defineConfig, getEncodedText, getFileSource, getPathMode, getRelativePath, getStackTrace, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, renderTemplate, timeout, transformReservedWord, validatePlugins, write, writeIndexes };