@kubb/cli 1.1.13 → 1.2.1

package/dist/index.cjs

@@ -6,10 +6,9 @@ var ora = require('ora');
 var pc3 = require('picocolors');
 var core = require('@kubb/core');
 var execa = require('execa');
+var perf_hooks = require('perf_hooks');
 var stringArgv = require('string-argv');
 var stream = require('stream');
-var mod = require('module');
-var url = require('url');
 var cosmiconfig = require('cosmiconfig');
 var tsNode = require('ts-node');
 var yaml = require('yaml');
@@ -20,7 +19,6 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var pathParser__default = /*#__PURE__*/_interopDefault(pathParser);
 var ora__default = /*#__PURE__*/_interopDefault(ora);
 var pc3__default = /*#__PURE__*/_interopDefault(pc3);
-var mod__default = /*#__PURE__*/_interopDefault(mod);
 var tsNode__default = /*#__PURE__*/_interopDefault(tsNode);
 var yaml__default = /*#__PURE__*/_interopDefault(yaml);
 var PrettyError__default = /*#__PURE__*/_interopDefault(PrettyError);
@@ -34,7 +32,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // package.json
-var version = "1.1.13";
+var version = "1.2.1";
 var presets = {
   simple: {
     "kubb.config": `
@@ -62,25 +60,32 @@ export default defineConfig({
     packages: ["@kubb/core", "@kubb/cli", "@kubb/swagger", "@kubb/swagger-ts", "@kubb/swagger-tanstack-query"]
   }
 };
-async function init({ spinner: spinner2, preset = "simple", logLevel = "silent", packageManager = "pnpm" }) {
+async function init({ preset = "simple", logLevel = core.LogLevel.silent, packageManager = "pnpm" }) {
+  spinner.start("\u{1F4E6} Initializing Kubb");
   const presetMeta = presets[preset];
   const path = pathParser__default.default.resolve(process.cwd(), "./kubb.config.js");
   const installCommand = packageManager === "npm" ? "install" : "add";
-  spinner2.start(`\u{1F4C0} Writing \`kubb.config.js\` ${pc3__default.default.dim(path)}`);
+  spinner.start(`\u{1F4C0} Writing \`kubb.config.js\` ${pc3__default.default.dim(path)}`);
   await core.write(presetMeta["kubb.config"], path);
-  spinner2.succeed(`\u{1F4C0} Wrote \`kubb.config.js\` ${pc3__default.default.dim(path)}`);
-  const data = await Promise.all([
+  spinner.succeed(`\u{1F4C0} Wrote \`kubb.config.js\` ${pc3__default.default.dim(path)}`);
+  const results = await Promise.allSettled([
     execa.$`npm init es6 -y`,
     ...presetMeta.packages.map(async (pack) => {
-      spinner2.start(`\u{1F4C0} Installing ${pc3__default.default.dim(pack)}`);
+      spinner.start(`\u{1F4C0} Installing ${pc3__default.default.dim(pack)}`);
       const { stdout } = await execa.$({ preferLocal: false })`${packageManager} ${installCommand} ${pack}`;
-      spinner2.succeed(`\u{1F4C0} Installed ${pc3__default.default.dim(pack)}`);
+      spinner.succeed(`\u{1F4C0} Installed ${pc3__default.default.dim(pack)}`);
       return stdout;
     })
   ]);
-  if (logLevel === "info") {
-    data.forEach((text) => console.log(text));
+  if (core.canLogHierarchy(logLevel, core.LogLevel.info)) {
+    results.forEach((result) => {
+      if (core.isPromiseFulfilledResult(result)) {
+        console.log(result.value);
+      }
+    });
   }
+  spinner.succeed(`\u{1F4E6} initialized Kubb`);
+  return;
 }
 
 // src/utils/parseHrtimeToSeconds.ts
@@ -88,9 +93,7 @@ function parseHrtimeToSeconds(hrtime) {
   const seconds = (hrtime[0] + hrtime[1] / 1e9).toFixed(3);
   return seconds;
 }
-
-// src/utils/parseText.ts
-function parseText(baseText, config, logLevel = "silent") {
+function parseText(baseText, config, logLevel = core.LogLevel.silent) {
   return `${baseText}${config[logLevel] || ""}`;
 }
 var OraWritable = class extends stream.Writable {
@@ -110,94 +113,100 @@ ${pc3__default.default.bold(pc3__default.default.blue(this.command))}: ${chunk?.
 };
 
 // src/run.ts
-async function run({ config, options }) {
-  const hrstart = process.hrtime();
-  const [log] = core.throttle((message, { logLevel, params }) => {
-    if (logLevel === "error") {
-      throw new Error(message || "Something went wrong");
-    } else if (logLevel === "info") {
-      if (message) {
-        spinner.text = message;
-      } else {
-        spinner.text = `\u{1FA82} Executing ${params?.hookName || "unknown"}(${pc3__default.default.yellow(params?.pluginName || "unknown")})`;
-      }
+async function executeHooks({ hooks, logLevel }) {
+  if (!hooks?.done) {
+    return;
+  }
+  const commands = Array.isArray(hooks.done) ? hooks.done : [hooks.done];
+  if (core.canLogHierarchy(logLevel, core.LogLevel.silent)) {
+    spinner.start(`Executing hooks`);
+  }
+  const executers = commands.map(async (command) => {
+    const oraWritable = new OraWritable(spinner, command);
+    const abortController = new AbortController();
+    const [cmd, ..._args] = [...stringArgv.parseArgsStringToArgv(command)];
+    spinner.start(parseText(`Executing hook`, { info: ` ${pc3__default.default.dim(command)}` }, logLevel));
+    const subProcess = await execa.execa(cmd, _args, { detached: true, signal: abortController.signal }).pipeStdout(oraWritable);
+    spinner.suffixText = "";
+    if (core.canLogHierarchy(logLevel, core.LogLevel.info)) {
+      spinner.succeed(parseText(`Executing hook`, { info: ` ${pc3__default.default.dim(command)}` }, logLevel));
+      console.log(subProcess.stdout);
     }
-  }, 100);
-  const logger = {
-    log,
-    spinner
-  };
-  const onDone = async (hooks, logLevel) => {
-    if (!hooks?.done) {
-      return;
+    await core.timeout(100);
+    oraWritable.destroy();
+    return { subProcess, abort: abortController.abort.bind(abortController) };
+  });
+  await Promise.all(executers);
+  if (core.canLogHierarchy(logLevel, core.LogLevel.silent)) {
+    spinner.succeed(`Executing hooks`);
+  }
+}
+function getSummary({ pluginManager, status, hrstart, config, logLevel }) {
+  const logs = [];
+  const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrstart));
+  const buildStartPlugins = [
+    ...new Set(pluginManager.executed.filter((item) => item.hookName === "buildStart" && item.plugin.name !== "core").map((item) => item.plugin.name))
+  ];
+  const failedPlugins = config.plugins?.filter((plugin) => !buildStartPlugins.includes(plugin.name))?.map((plugin) => plugin.name);
+  const pluginsCount = config.plugins?.length || 0;
+  const files = pluginManager.fileManager.files.sort((a, b) => {
+    if (!a.meta?.pluginName || !b.meta?.pluginName) {
+      return 0;
     }
-    let commands = [];
-    if (typeof hooks?.done === "string") {
-      commands = [hooks.done];
-    } else {
-      commands = hooks.done;
+    if (a.meta?.pluginName.length < b.meta?.pluginName.length) {
+      return 1;
     }
-    const promises = commands.map(async (command) => {
-      const oraWritable = new OraWritable(spinner, command);
-      const [cmd, ..._args] = [...stringArgv.parseArgsStringToArgv(command)];
-      spinner.start(parseText(`\u{1FA82} Executing hooks(${pc3__default.default.yellow("done")})`, { info: ` ${pc3__default.default.dim(command)}` }, logLevel));
-      const { stdout } = await execa.execa(cmd, _args, {}).pipeStdout(oraWritable);
-      spinner.suffixText = "";
-      oraWritable.destroy();
-      await core.timeout(50);
-      if (logLevel === "info") {
-        spinner.succeed(parseText(`\u{1FA82} Executing hooks(${pc3__default.default.yellow("done")})`, { info: ` ${pc3__default.default.dim(command)}` }, logLevel));
-        console.log(stdout);
-      }
-    });
-    await Promise.all(promises);
-    if (logLevel === "silent") {
-      spinner.succeed(parseText(`\u{1FA82} Executing hooks(${pc3__default.default.yellow("done")})`, {}, logLevel));
+    if (a.meta?.pluginName.length > b.meta?.pluginName.length) {
+      return -1;
     }
+    return 0;
+  });
+  const meta = {
+    plugins: status === "success" ? `${pc3__default.default.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${pc3__default.default.red(`${failedPlugins?.length || 0} failed`)}, ${pluginsCount} total`,
+    pluginsFailed: status === "failed" ? failedPlugins?.map((name) => core.randomPicoColour(name))?.join(", ") : void 0,
+    filesCreated: files.length,
+    time: pc3__default.default.yellow(`${elapsedSeconds}s`),
+    output: pathParser__default.default.resolve(config.root, config.output.path)
   };
-  const getSummary = (pluginManager, status) => {
-    const logs = [];
-    const elapsedSeconds = parseHrtimeToSeconds(process.hrtime(hrstart));
-    const buildStartPlugins = [
-      ...new Set(pluginManager.executed.filter((item) => item.hookName === "buildStart" && item.plugin.name !== "core").map((item) => item.plugin.name))
-    ];
-    const pluginsCount = config.plugins?.length || 0;
-    const files = pluginManager.fileManager.files.sort((a, b) => {
-      if (!a.meta?.pluginName || !b.meta?.pluginName) {
-        return 0;
-      }
-      if (a.meta?.pluginName.length < b.meta?.pluginName.length) {
-        return 1;
-      }
-      if (a.meta?.pluginName.length > b.meta?.pluginName.length) {
-        return -1;
+  if (core.canLogHierarchy(logLevel, "stacktrace")) {
+    logs.push(pc3__default.default.bold("Generated files:\n"));
+    logs.push(files.map((file) => `${core.randomPicoColour(file.meta?.pluginName)} ${file.path}`).join("\n"));
+  }
+  logs.push(
+    [
+      [`
+`, true],
+      [`  ${pc3__default.default.bold("Plugins:")}      ${meta.plugins}`, true],
+      [`   ${pc3__default.default.dim("Failed:")}      ${meta.pluginsFailed || "none"}`, !!meta.pluginsFailed],
+      [`${pc3__default.default.bold("Generated:")}      ${meta.filesCreated} files`, true],
+      [`     ${pc3__default.default.bold("Time:")}      ${meta.time}`, true],
+      [`   ${pc3__default.default.bold("Output:")}      ${meta.output}`, true],
+      [`
+`, true]
+    ].map((item) => {
+      if (item.at(1)) {
+        return item.at(0);
       }
-      return 0;
-    });
-    const meta = {
-      plugins: status === "success" ? `${pc3__default.default.green(`${buildStartPlugins.length} successful`)}, ${pluginsCount} total` : `${pc3__default.default.red(`${pluginsCount - buildStartPlugins.length + 1} failed`)}, ${pluginsCount} total`,
-      filesCreated: files.length,
-      time: pc3__default.default.yellow(`${elapsedSeconds}s`),
-      output: pathParser__default.default.resolve(config.root, config.output.path)
-    };
-    if (options.debug) {
-      logs.push(pc3__default.default.bold("Generated files:\n"));
-      logs.push(files.map((file) => `${pc3__default.default.blue(file.meta?.pluginName)} ${file.path}`).join("\n"));
-    }
-    logs.push(`
-
-  ${pc3__default.default.bold("Plugins:")}      ${meta.plugins}
-${pc3__default.default.bold("Generated:")}      ${meta.filesCreated} files
-     ${pc3__default.default.bold("Time:")}      ${meta.time}
-   ${pc3__default.default.bold("Output:")}      ${meta.output}
-     
-`);
-    return logs;
-  };
+      return void 0;
+    }).filter(Boolean).join("\n")
+  );
+  return logs;
+}
+async function run({ config, CLIOptions }) {
+  const hrstart = process.hrtime();
+  const logger = core.createLogger(spinner);
+  const performanceOpserver = new perf_hooks.PerformanceObserver((items) => {
+    const message = `${items.getEntries()[0].duration.toFixed(0)}ms`;
+    spinner.suffixText = pc3__default.default.yellow(message);
+    perf_hooks.performance.clearMarks();
+  });
+  if (CLIOptions.debug) {
+    performanceOpserver.observe({ type: "measure" });
+  }
   try {
-    const { root, ...userConfig } = config;
-    const logLevel = options.logLevel ?? userConfig.logLevel ?? "silent";
-    const inputPath = options.input ?? userConfig.input.path;
+    const { root: _root, ...userConfig } = config;
+    const logLevel = CLIOptions.logLevel ?? userConfig.logLevel ?? core.LogLevel.silent;
+    const inputPath = CLIOptions.input ?? userConfig.input.path;
     spinner.start(parseText(`\u{1F680} Building`, { info: `(${pc3__default.default.dim(inputPath)})` }, logLevel));
     const output = await core.build({
       config: {
@@ -213,38 +222,23 @@ ${pc3__default.default.bold("Generated:")}      ${meta.filesCreated} files
           ...userConfig.output
         }
       },
-      logger
+      logger,
+      debug: CLIOptions.debug
     });
+    spinner.suffixText = "";
     spinner.succeed(parseText(`\u{1F680} Build completed`, { info: `(${pc3__default.default.dim(inputPath)})` }, logLevel));
-    await onDone(config.hooks, logLevel);
-    const summary = getSummary(output.pluginManager, "success");
+    await core.timeout(100);
+    await executeHooks({ hooks: config.hooks, logLevel, debug: CLIOptions.debug });
+    const summary = getSummary({ pluginManager: output.pluginManager, config, status: "success", hrstart, logLevel: CLIOptions.logLevel });
     console.log(summary.join(""));
   } catch (error) {
+    let summary = [];
     if (error instanceof core.PluginError || error instanceof core.ParallelPluginError) {
-      const summary = getSummary(error.pluginManager, "failed");
-      throw new core.SummaryError("Something went wrong\n", { cause: error, summary });
+      summary = getSummary({ pluginManager: error.pluginManager, config, status: "failed", hrstart, logLevel: CLIOptions.logLevel });
     }
-    throw new core.SummaryError("Something went wrong\n", { cause: error });
-  }
-}
-var SLASHES = /* @__PURE__ */ new Set(["/", "\\"]);
-function normalizeDirectory(directory) {
-  if (!SLASHES.has(directory[directory.length - 1])) {
-    return `${directory}/`;
-  }
-  return directory;
-}
-async function importModule(path, cwd) {
-  let location = path;
-  if (cwd) {
-    const require2 = mod__default.default.createRequire(normalizeDirectory(cwd));
-    location = require2.resolve(path);
+    throw new core.SummaryError("Something went wrong\n", { cause: error, summary });
   }
-  const module = await import(url.pathToFileURL(location).href);
-  return module?.default ?? module;
 }
-
-// src/utils/getPlugins.ts
 function isJSONPlugins(plugins) {
   return !!plugins?.some((plugin) => {
     return typeof plugin?.[0] === "string";
@@ -254,18 +248,18 @@ function isObjectPlugins(plugins) {
   return plugins instanceof Object && !Array.isArray(plugins);
 }
 async function importPlugin(name, options) {
-  const importedPlugin = process.env.NODE_ENV === "test" ? await import(name) : await importModule(name, process.cwd());
+  const importedPlugin = process.env.NODE_ENV === "test" ? await import(name) : await core.importModule(name, process.cwd());
   return importedPlugin?.default ? importedPlugin.default(options) : importedPlugin(options);
 }
 function getPlugins(plugins) {
   if (isObjectPlugins(plugins)) {
-    const promises = Object.keys(plugins).map(async (name) => {
+    const promises = Object.keys(plugins).map((name) => {
       return importPlugin(name, plugins[name]);
     });
     return Promise.all(promises);
   }
   if (isJSONPlugins(plugins)) {
-    const promises = plugins.map(async (plugin) => {
+    const promises = plugins.map((plugin) => {
       const [name, options = {}] = plugin;
       return importPlugin(name, options);
     });
@@ -275,11 +269,11 @@ function getPlugins(plugins) {
 }
 
 // src/utils/getConfig.ts
-async function getConfig(result, options) {
+async function getConfig(result, CLIOptions) {
   const config = result?.config;
   let kubbUserConfig = Promise.resolve(config);
   if (typeof config === "function") {
-    const possiblePromise = config(options);
+    const possiblePromise = config(CLIOptions);
     if (core.isPromise(possiblePromise)) {
       kubbUserConfig = possiblePromise;
     }
@@ -308,9 +302,10 @@ async function startWatcher(path, cb) {
       spinner.warn(pc3__default.default.red("Watcher failed"));
     }
   });
+  return;
 }
 var jsLoader = async (configFile) => {
-  return importModule(configFile);
+  return core.importModule(configFile);
 };
 var tsLoader = (configFile) => {
   let registerer = { enabled() {
@@ -384,14 +379,14 @@ function getErrorCauses(errors) {
     return prev;
   }, []).filter(Boolean);
 }
-function renderErrors(error, { prefixText, debug = false }) {
+function renderErrors(error, { prefixText, logLevel = core.LogLevel.silent }) {
   if (!error) {
     return "";
   }
   if (error instanceof core.ParallelPluginError) {
-    return [prefixText, ...error.errors.map((e) => renderErrors(e, { debug }))].filter(Boolean).join("\n");
+    return [prefixText, ...error.errors.map((e) => renderErrors(e, { logLevel }))].filter(Boolean).join("\n");
   }
-  if (debug) {
+  if (core.canLogHierarchy(logLevel, "stacktrace")) {
     const errors = getErrorCauses([error]);
     return [prefixText, ...errors].filter(Boolean).join("\n");
   }
@@ -405,52 +400,61 @@ var moduleName = "kubb";
 var spinner = ora__default.default({
   spinner: "clock"
 });
+function programCatcher(e, CLIOptions) {
+  const originalError = e;
+  let error = originalError;
+  const summaryError = error instanceof core.SummaryError ? error : void 0;
+  if (summaryError) {
+    error = summaryError.cause;
+  }
+  const message = renderErrors(error, { logLevel: CLIOptions.logLevel, prefixText: pc3__default.default.red(originalError?.message) });
+  if (error instanceof core.Warning) {
+    spinner.warn(pc3__default.default.yellow(error.message));
+    process.exit(0);
+  }
+  if (core.canLogHierarchy(CLIOptions.logLevel, core.LogLevel.silent)) {
+    spinner.fail(message);
+    process.exit(1);
+  }
+  spinner.fail([message, ...summaryError?.summary || []].join("\n"));
+  process.exit(1);
+}
 var program = new commander.Command(moduleName).name(moduleName).description("Kubb").version(version, "-v").exitOverride((err) => {
   if (err instanceof commander.CommanderError) {
     process.exit(1);
   }
 }).configureOutput({
   outputError: (message, write2) => {
-    const options = program.opts();
+    const CLIOptions = program.opts();
     write2(
-      renderErrors(new Error(message, { cause: void 0 }), { debug: options.debug, prefixText: pc3__default.default.red("Something went wrong with processing the CLI\n") }) + "\n"
+      renderErrors(new Error(message, { cause: void 0 }), {
+        logLevel: CLIOptions.logLevel,
+        prefixText: pc3__default.default.red("Something went wrong with processing the CLI\n")
+      }) + "\n"
     );
   }
-}).action(async (options) => {
+}).addOption(new commander.Option("-c, --config <path>", "Path to the Kubb config")).addOption(new commander.Option("-i, --input <path>", "Path of the input file(overrides the one in `kubb.config.js`)")).addOption(new commander.Option("-l, --logLevel <type>", "Type of the logging(overrides the one in `kubb.config.js`)").choices(["info", "silent", "stacktrace"])).addOption(new commander.Option("--init", "Init Kubb")).addOption(new commander.Option("-d, --debug", "Debug mode").default(false)).addOption(new commander.Option("-w, --watch", "Watch mode based on the input file")).action(async (options) => {
   try {
-    spinner.start();
     if (options.init) {
-      spinner.start("\u{1F4E6} Initializing Kubb");
-      await init({ spinner, logLevel: options.logLevel });
-      spinner.succeed(`\u{1F4E6} initialized Kubb`);
-      return;
+      return init({ logLevel: options.logLevel });
     }
     spinner.start("\u{1F4BE} Loading config");
     const result = await getCosmiConfig(moduleName, options.config);
     spinner.succeed(`\u{1F4BE} Config loaded(${pc3__default.default.dim(pathParser__default.default.relative(process.cwd(), result.filepath))})`);
     if (options.watch) {
-      const config = await getConfig(result, options);
-      startWatcher([config.input.path], async (paths) => {
-        await run({ config, options });
+      const config2 = await getConfig(result, options);
+      return startWatcher([config2.input.path], async (paths) => {
+        await run({ config: config2, CLIOptions: options });
         spinner.spinner = "simpleDotsScrolling";
         spinner.start(pc3__default.default.yellow(pc3__default.default.bold(`Watching for changes in ${paths.join(" and ")}`)));
       });
-    } else {
-      const config = await getConfig(result, options);
-      await run({ config, options });
     }
+    const config = await getConfig(result, options);
+    await run({ config, CLIOptions: options });
   } catch (e) {
-    const originalError = e;
-    let error = originalError;
-    const summaryError = error instanceof core.SummaryError ? error : void 0;
-    if (summaryError) {
-      error = summaryError.cause;
-    }
-    const message = renderErrors(error, { debug: options.debug, prefixText: pc3__default.default.red(originalError?.message) });
-    spinner.fail([message, ...summaryError?.summary || []].join("\n"));
-    process.exit(1);
+    programCatcher(e, options);
   }
-}).addOption(new commander.Option("-c, --config <path>", "Path to the Kubb config")).addOption(new commander.Option("-i, --input <path>", "Path of the input file(overrides the one in `kubb.config.js`)")).addOption(new commander.Option("-l, --logLevel <type>", "Type of the logging(overrides the one in `kubb.config.js`)").choices(["error", "info", "silent"])).addOption(new commander.Option("--init", "Init Kubb")).addOption(new commander.Option("-d, --debug", "Debug mode").default(false)).addOption(new commander.Option("-w, --watch", "Watch mode based on the input file"));
+});
 
 // src/index.ts
 function runCLI(argv) {