@kubb/core 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/index.d.ts

@@ -105,9 +105,9 @@ type KubbPlugin<TOptions extends PluginFactoryOptions = PluginFactoryOptions> =
      */
     options?: TOptions['options'];
 } & Partial<PluginLifecycle<TOptions>>;
-type PluginFactoryOptions<Options = unknown, Nested extends boolean = false, Api = any, ResolveIdOptions = Record<string, any>> = {
+type PluginFactoryOptions<Options = unknown, Nested extends boolean = false, Api = any, resolvePathOptions = Record<string, any>> = {
     options: Options;
-    resolveIdOptions: ResolveIdOptions;
+    resolvePathOptions: resolvePathOptions;
     nested: Nested;
     api: Api;
 };
@@ -123,13 +123,21 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      */
     buildStart: (this: PluginContext, kubbConfig: KubbConfig) => MaybePromise<void>;
     /**
-     * Resolve to an id based on importee(example: `./Pet.ts`) and directory(example: `./models`).
+     * Resolve to a Path based on a fileName(example: `./Pet.ts`) and directory(example: `./models`).
+     * Options can als be included.
      * @type hookFirst
-     * @example ('./Pet.ts', './src/gen/')
+     * @example ('./Pet.ts', './src/gen/') => '/src/gen/Pet.ts'
      */
-    resolveId: (this: Omit<PluginContext, 'addFile'>, fileName: string, directory?: string, options?: TOptions['resolveIdOptions']) => OptionalPath;
+    resolvePath: (this: Omit<PluginContext, 'addFile'>, fileName: string, directory?: string, options?: TOptions['resolvePathOptions']) => OptionalPath;
     /**
-     * Makes it possible to run async logic to override the path defined previously by `resolveId`.
+     * Resolve to a name based on a string.
+     * Useful when converting to PascalCase or camelCase.
+     * @type hookFirst
+     * @example ('pet') => 'Pet'
+     */
+    resolveName: (this: Omit<PluginContext, 'addFile'>, name: string) => string | null;
+    /**
+     * Makes it possible to run async logic to override the path defined previously by `resolvePath`.
      * @type hookFirst
      */
     load: (this: Omit<PluginContext, 'addFile'>, path: Path) => MaybePromise<TransformResult | null>;
@@ -139,7 +147,7 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
      */
     transform: (this: Omit<PluginContext, 'addFile'>, source: string, path: Path) => MaybePromise<TransformResult>;
     /**
-     * Write the result to the file-system based on the id(defined by `resolveId` or changed by `load`).
+     * Write the result to the file-system based on the id(defined by `resolvePath` or changed by `load`).
      * @type hookParallel
      */
     writeFile: (this: Omit<PluginContext, 'addFile'>, source: string | undefined, path: Path) => MaybePromise<void>;
@@ -150,25 +158,34 @@ type PluginLifecycle<TOptions extends PluginFactoryOptions = PluginFactoryOption
     buildEnd: (this: Omit<PluginContext, 'addFile'>) => MaybePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
-type ResolveIdParams<TOptions = Record<string, any>> = {
-    fileName: string;
-    directory?: string | undefined;
+type ResolvePathParams<TOptions = Record<string, any>> = {
     /**
-     * When set, resolveId will only call resolveId of the name of the plugin set here.
-     * If not defined it will fall back on the resolveId of the core plugin.
+     * When set, resolvePath will only call resolvePath of the name of the plugin set here.
+     * If not defined it will fall back on the resolvePath of the core plugin.
      */
     pluginName?: string;
+    fileName: string;
+    directory?: string | undefined;
     /**
-     * Options to be passed to 'resolveId' 3th parameter
+     * Options to be passed to 'resolvePath' 3th parameter
      */
     options?: TOptions;
 };
+type ResolveNameParams = {
+    /**
+     * When set, resolvePath will only call resolvePath of the name of the plugin set here.
+     * If not defined it will fall back on the resolvePath of the core plugin.
+     */
+    pluginName?: string;
+    name: string;
+};
 type PluginContext<TOptions = Record<string, any>> = {
     config: KubbConfig;
     cache: Cache;
     fileManager: FileManager;
     addFile: (file: File) => Promise<File>;
-    resolveId: (params: ResolveIdParams<TOptions>) => MaybePromise<OptionalPath>;
+    resolvePath: (params: ResolvePathParams<TOptions>) => OptionalPath;
+    resolveName: (params: ResolveNameParams) => string | null;
     load: (id: string) => MaybePromise<TransformResult | void>;
 };
 type TransformResult = string | null;
@@ -204,8 +221,8 @@ declare function nameSorter<T extends {
 }>(a: T, b: T): 0 | 1 | -1;
 
 declare function createJSDocBlockText({ comments }: {
-    comments: Array<string | undefined>;
-}): string | undefined;
+    comments: Array<string>;
+}): string;
 
 declare function getUniqueName(originalName: string, data: Record<string, number>): string;
 
@@ -322,7 +339,8 @@ declare function createPlugin<T extends PluginFactoryOptions = PluginFactoryOpti
 type Options = {
     config: PluginContext['config'];
     fileManager: FileManager;
-    resolveId: PluginContext['resolveId'];
+    resolvePath: PluginContext['resolvePath'];
+    resolveName: PluginContext['resolveName'];
     load: PluginContext['load'];
 };
 type CorePluginOptions = PluginFactoryOptions<Options, false, PluginContext>;
@@ -347,14 +365,56 @@ declare class PluginManager {
         logger?: Logger;
         task: QueueTask;
     });
-    resolveId: (params: ResolveIdParams) => Promise<OptionalPath>;
+    resolvePath: (params: ResolvePathParams) => OptionalPath;
+    resolveName: (params: ResolveNameParams) => string | null;
     load: (id: string) => Promise<TransformResult>;
-    hookForPlugin<H extends PluginLifecycleHooks>(pluginName: string, hookName: H, parameters: Parameters<PluginLifecycle[H]>, skipped?: ReadonlySet<KubbPlugin> | null): Promise<ReturnType<PluginLifecycle[H]> | null>;
-    hookFirst<H extends PluginLifecycleHooks>(hookName: H, parameters: Parameters<PluginLifecycle[H]>, skipped?: ReadonlySet<KubbPlugin> | null): Promise<ReturnType<PluginLifecycle[H]> | null>;
-    hookParallel<H extends PluginLifecycleHooks, TOuput = void>(hookName: H, parameters?: Parameters<PluginLifecycle[H]> | undefined): Promise<Awaited<TOuput>[]>;
-    hookReduceArg0<H extends PluginLifecycleHooks>(hookName: H, [argument0, ...rest]: Parameters<PluginLifecycle[H]>, reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>): Promise<Argument0<H>>;
-    hookSeq<H extends PluginLifecycleHooks>(hookName: H, parameters?: Parameters<PluginLifecycle[H]>): Promise<void>;
+    /**
+     *
+     * Run only hook for a specific plugin name
+     */
+    hookForPlugin<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
+        pluginName: string;
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+    }): Promise<ReturnType<PluginLifecycle[H]> | null>;
+    hookForPluginSync<H extends PluginLifecycleHooks>({ pluginName, hookName, parameters, }: {
+        pluginName: string;
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+    }): ReturnType<PluginLifecycle[H]> | null;
+    /**
+     *
+     * Chains, first non-null result stops and returns
+     */
+    hookFirst<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+        skipped?: ReadonlySet<KubbPlugin> | null;
+    }): Promise<ReturnType<PluginLifecycle[H]> | null>;
+    /**
+     *
+     * Chains, first non-null result stops and returns
+     */
+    hookFirstSync<H extends PluginLifecycleHooks>({ hookName, parameters, skipped, }: {
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+        skipped?: ReadonlySet<KubbPlugin> | null;
+    }): ReturnType<PluginLifecycle[H]> | null;
+    hookParallel<H extends PluginLifecycleHooks, TOuput = void>({ hookName, parameters, }: {
+        hookName: H;
+        parameters?: Parameters<PluginLifecycle[H]> | undefined;
+    }): Promise<Awaited<TOuput>[]>;
+    hookReduceArg0<H extends PluginLifecycleHooks>({ hookName, parameters, reduce, }: {
+        hookName: H;
+        parameters: Parameters<PluginLifecycle[H]>;
+        reduce: (reduction: Argument0<H>, result: ReturnType<PluginLifecycle[H]>, plugin: KubbPlugin) => MaybePromise<Argument0<H> | null>;
+    }): Promise<Argument0<H>>;
+    hookSeq<H extends PluginLifecycleHooks>({ hookName, parameters }: {
+        hookName: H;
+        parameters?: Parameters<PluginLifecycle[H]>;
+    }): Promise<void>;
     private getSortedPlugins;
+    private getPlugin;
     /**
      * Run an async plugin hook and return the result.
      * @param hookName Name of the plugin hook. Must be either in `PluginHooks` or `OutputPluginValueHooks`.
@@ -395,4 +455,4 @@ declare abstract class SchemaGenerator<TOptions extends object, TInput, TOutput>
     abstract build(schema: TInput, name: string, description?: string): TOutput;
 }
 
-export { Argument0, CLIOptions, Cache, CacheStore, CorePluginOptions, File, FileManager, FileName, Generator, KubbBuild, KubbConfig, KubbJSONPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, LogType, Logger, MaybePromise, OptionalPath, Path, PathMode, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, ResolveIdParams, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getFileSource, getPathMode, getRelativePath, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, timeout, validatePlugins, write };
+export { Argument0, CLIOptions, Cache, CacheStore, CorePluginOptions, File, FileManager, FileName, Generator, KubbBuild, KubbConfig, KubbJSONPlugin, KubbPlugin, KubbPluginKind, KubbUserConfig, LogLevel, LogType, Logger, MaybePromise, OptionalPath, Path, PathMode, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, Queue, QueueTask, ResolveNameParams, ResolvePathParams, SchemaGenerator, Status, Strategy, TransformResult, TreeNode, TreeNodeOptions, UUID, ValidationPluginError, build, clean, combineFiles, createJSDocBlockText, createPlugin, createPluginCache, build as default, defineConfig, getFileSource, getPathMode, getRelativePath, getUniqueName, hooks, isPromise, isURL, name, nameSorter, objectToParameters, read, timeout, validatePlugins, write };

package/dist/index.js

@@ -139,7 +139,7 @@ function nameSorter(a, b) {
 function createJSDocBlockText({ comments }) {
   const filteredComments = comments.filter(Boolean);
   if (!filteredComments.length) {
-    return void 0;
+    return "";
   }
   const text = filteredComments.reduce((acc, comment) => {
     return `${acc}
@@ -214,7 +214,7 @@ function createPlugin(factory) {
 }
 var name = "core";
 var definePlugin = createPlugin((options) => {
-  const { fileManager, resolveId, load } = options;
+  const { fileManager, resolvePath, resolveName, load } = options;
   const api = {
     get config() {
       return options.config;
@@ -223,7 +223,8 @@ var definePlugin = createPlugin((options) => {
     async addFile(file) {
       return fileManager.addOrAppend(file);
     },
-    resolveId,
+    resolvePath,
+    resolveName,
     load,
     cache: createPluginCache(/* @__PURE__ */ Object.create(null))
   };
@@ -231,11 +232,14 @@ var definePlugin = createPlugin((options) => {
     name,
     options,
     api,
-    resolveId(fileName, directory) {
+    resolvePath(fileName, directory) {
       if (!directory) {
         return null;
       }
       return pathParser2.resolve(directory, fileName);
+    },
+    resolveName(name2) {
+      return name2;
     }
   };
 });
@@ -457,7 +461,8 @@ ${file.source}`;
 var hookNames = {
   validate: 1,
   buildStart: 1,
-  resolveId: 1,
+  resolvePath: 1,
+  resolveName: 1,
   load: 1,
   transform: 1,
   writeFile: 1,
@@ -480,95 +485,196 @@ var PluginManager = class {
       config,
       fileManager: this.fileManager,
       load: this.load,
-      resolveId: this.resolveId
+      resolvePath: this.resolvePath,
+      resolveName: this.resolveName
     });
     this.plugins = [this.core, ...config.plugins || []];
   }
-  resolveId = (params) => {
+  resolvePath = (params) => {
+    if (params.pluginName) {
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolvePath",
+        parameters: [params.fileName, params.directory, params.options]
+      });
+    }
+    return this.hookFirstSync({
+      hookName: "resolvePath",
+      parameters: [params.fileName, params.directory, params.options]
+    });
+  };
+  resolveName = (params) => {
     if (params.pluginName) {
-      return this.hookForPlugin(params.pluginName, "resolveId", [params.fileName, params.directory, params.options]);
+      return this.hookForPluginSync({
+        pluginName: params.pluginName,
+        hookName: "resolveName",
+        parameters: [params.name]
+      });
     }
-    return this.hookFirst("resolveId", [params.fileName, params.directory, params.options]);
+    return this.hookFirstSync({
+      hookName: "resolveName",
+      parameters: [params.name]
+    });
   };
   load = async (id) => {
-    return this.hookFirst("load", [id]);
+    return this.hookFirst({
+      hookName: "load",
+      parameters: [id]
+    });
   };
-  // run only hook for a specific plugin name
-  hookForPlugin(pluginName, hookName, parameters, skipped) {
+  /**
+   *
+   * Run only hook for a specific plugin name
+   */
+  hookForPlugin({
+    pluginName,
+    hookName,
+    parameters
+  }) {
+    const plugin = this.getPlugin(hookName, pluginName);
+    return this.run({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
+  }
+  hookForPluginSync({
+    pluginName,
+    hookName,
+    parameters
+  }) {
+    const plugin = this.getPlugin(hookName, pluginName);
+    return this.runSync({
+      strategy: "hookFirst",
+      hookName,
+      parameters,
+      plugin
+    });
+  }
+  /**
+   *
+   * Chains, first non-null result stops and returns
+   */
+  hookFirst({
+    hookName,
+    parameters,
+    skipped
+  }) {
     let promise = Promise.resolve(null);
-    for (const plugin of this.getSortedPlugins(hookName, pluginName)) {
+    for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
       promise = promise.then((result) => {
         if (result != null)
           return result;
-        return this.run("hookFirst", hookName, parameters, plugin);
+        return this.run({
+          strategy: "hookFirst",
+          hookName,
+          parameters,
+          plugin
+        });
       });
     }
     return promise;
   }
-  // chains, first non-null result stops and returns
-  hookFirst(hookName, parameters, skipped) {
-    let promise = Promise.resolve(null);
+  /**
+   *
+   * Chains, first non-null result stops and returns
+   */
+  hookFirstSync({
+    hookName,
+    parameters,
+    skipped
+  }) {
+    let result = null;
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (skipped && skipped.has(plugin))
         continue;
-      promise = promise.then((result) => {
-        if (result != null)
-          return result;
-        return this.run("hookFirst", hookName, parameters, plugin);
+      result = this.runSync({
+        strategy: "hookFirst",
+        hookName,
+        parameters,
+        plugin
       });
+      if (result != null) {
+        break;
+      }
     }
-    return promise;
+    return result;
   }
   // parallel
-  async hookParallel(hookName, parameters) {
+  async hookParallel({
+    hookName,
+    parameters
+  }) {
     const parallelPromises = [];
     for (const plugin of this.getSortedPlugins(hookName)) {
       if (plugin[hookName]?.sequential) {
         await Promise.all(parallelPromises);
         parallelPromises.length = 0;
-        await this.run("hookParallel", hookName, parameters, plugin);
+        await this.run({
+          strategy: "hookParallel",
+          hookName,
+          parameters,
+          plugin
+        });
       } else {
-        const promise = this.run("hookParallel", hookName, parameters, plugin);
+        const promise = this.run({ strategy: "hookParallel", hookName, parameters, plugin });
         parallelPromises.push(promise);
       }
     }
     return Promise.all(parallelPromises);
   }
   // chains, reduces returned value, handling the reduced value as the first hook argument
-  hookReduceArg0(hookName, [argument0, ...rest], reduce) {
+  hookReduceArg0({
+    hookName,
+    parameters,
+    reduce
+  }) {
+    const [argument0, ...rest] = parameters;
     let promise = Promise.resolve(argument0);
     for (const plugin of this.getSortedPlugins(hookName)) {
       promise = promise.then(
-        (argument02) => this.run("hookReduceArg0", hookName, [argument02, ...rest], plugin).then(
-          (result) => reduce.call(this.core.api, argument02, result, plugin)
-        )
+        (argument02) => this.run({
+          strategy: "hookReduceArg0",
+          hookName,
+          parameters: [argument02, ...rest],
+          plugin
+        }).then((result) => reduce.call(this.core.api, argument02, result, plugin))
       );
     }
     return promise;
   }
   // chains
-  hookSeq(hookName, parameters) {
+  hookSeq({ hookName, parameters }) {
     let promise = Promise.resolve();
     for (const plugin of this.getSortedPlugins(hookName)) {
-      promise = promise.then(() => this.run("hookSeq", hookName, parameters, plugin));
+      promise = promise.then(
+        () => this.run({
+          strategy: "hookSeq",
+          hookName,
+          parameters,
+          plugin
+        })
+      );
     }
     return promise.then(noReturn);
   }
-  getSortedPlugins(hookName, pluginName) {
+  getSortedPlugins(_hookName) {
     const plugins = [...this.plugins];
-    if (pluginName) {
-      const pluginsByPluginName = plugins.filter((item) => item.name === pluginName && item[hookName]);
-      if (pluginsByPluginName.length === 0) {
-        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 plugins;
+  }
+  getPlugin(hookName, pluginName) {
+    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 pluginsByPluginName;
+      return this.core;
     }
-    return plugins;
+    return pluginByPluginName;
   }
   /**
    * Run an async plugin hook and return the result.
@@ -577,7 +683,12 @@ var PluginManager = class {
    * @param plugin The actual pluginObject to run.
    */
   // Implementation signature
-  run(strategy, hookName, parameters, plugin) {
+  run({
+    strategy,
+    hookName,
+    parameters,
+    plugin
+  }) {
     const hook = plugin[hookName];
     return Promise.resolve().then(() => {
       if (typeof hook !== "function") {
@@ -613,12 +724,21 @@ var PluginManager = class {
    * @param plugin The acutal plugin
    * @param replaceContext When passed, the plugin context can be overridden.
    */
-  runSync(hookName, parameters, plugin) {
+  runSync({
+    strategy,
+    hookName,
+    parameters,
+    plugin
+  }) {
     const hook = plugin[hookName];
     try {
+      if (typeof hook !== "function") {
+        return hook;
+      }
       return hook.apply(this.core.api, parameters);
-    } catch (error) {
-      return error;
+    } catch (e) {
+      this.catcher(e, plugin, hookName);
+      return null;
     }
   }
   catcher(e, plugin, hookName) {
@@ -664,22 +784,38 @@ async function buildImplementation(options, done) {
   const queueTask = async (id, file) => {
     const { path } = file;
     let code = getFileSource(file);
-    const loadedResult = await pluginManager.hookFirst("load", [path]);
+    const loadedResult = await pluginManager.hookFirst({
+      hookName: "load",
+      parameters: [path]
+    });
     if (loadedResult) {
       code = loadedResult;
     }
     if (code) {
-      const transformedCode = await pluginManager.hookReduceArg0("transform", [code, path], transformReducer);
+      const transformedCode = await pluginManager.hookReduceArg0({
+        hookName: "transform",
+        parameters: [code, path],
+        reduce: transformReducer
+      });
       if (config.output.write || config.output.write === void 0) {
-        await pluginManager.hookParallel("writeFile", [transformedCode, path]);
+        await pluginManager.hookParallel({
+          hookName: "writeFile",
+          parameters: [transformedCode, path]
+        });
       }
     }
   };
   const pluginManager = new PluginManager(config, { logger, task: queueTask });
   const { plugins, fileManager } = pluginManager;
-  await pluginManager.hookParallel("validate", [plugins]);
-  await pluginManager.hookParallel("buildStart", [config]);
-  await pluginManager.hookParallel("buildEnd");
+  await pluginManager.hookParallel({
+    hookName: "validate",
+    parameters: [plugins]
+  });
+  await pluginManager.hookParallel({
+    hookName: "buildStart",
+    parameters: [config]
+  });
+  await pluginManager.hookParallel({ hookName: "buildEnd" });
   setTimeout(() => {
     done({ files: fileManager.files.map((file) => ({ ...file, source: getFileSource(file) })) });
   }, 500);