@kubb/core 0.28.0 → 0.29.0

package/dist/index.d.ts

@@ -1,9 +1,6 @@
 import EventEmitter from 'events';
+import { DirectoryTreeOptions } from 'directory-tree';
 
-type GenerateTreeNodeOptions = {
-    extensions?: RegExp;
-    exclude?: RegExp[];
-};
 declare class TreeNode<T = unknown> {
     data: T;
     parent?: TreeNode<T>;
@@ -14,7 +11,7 @@ declare class TreeNode<T = unknown> {
     leaves(): this[];
     root(): any;
     forEach(callback: (treeNode: TreeNode<T>) => void): this;
-    static generate(path: string, options?: GenerateTreeNodeOptions): TreeNode<{
+    static generate(path: string, options?: DirectoryTreeOptions): TreeNode<{
         name: string;
         path: string;
         type: "file" | "directory";
@@ -65,8 +62,6 @@ type Status = 'new' | 'success' | 'removed';
 
 declare class FileManager {
     private cache;
-    private readonly root;
-    private readonly output;
     emitter: EventEmitter;
     events: {
         emitFile: (id: string, file: File) => void;
@@ -74,29 +69,23 @@ declare class FileManager {
         emitStatusChangeById: (id: string, status: Status) => void;
         emitSuccess: () => void;
         emitRemove: (id: string, file: File) => void;
-        onAdd: (callback: (id: string, file: File) => void) => VoidFunction;
-        onStatusChange: (callback: (file: File) => void) => VoidFunction;
-        onStatusChangeById: (id: string, callback: (status: Status) => void) => VoidFunction;
-        onSuccess: (callback: () => void) => VoidFunction;
-        onRemove: (id: string, callback: (file: File) => void) => VoidFunction;
+        onAdd: (callback: (id: string, file: File) => void) => () => void;
+        onStatusChange: (callback: (file: File) => void) => () => void;
+        onStatusChangeById: (id: string, callback: (status: Status) => void) => () => void;
+        onSuccess: (callback: () => void) => () => void;
+        onRemove: (id: string, callback: (file: File) => void) => () => void;
     };
-    constructor(options?: {
-        root?: string;
-        output?: string;
-    });
+    constructor();
     private getCache;
-    private getCountOfStatus;
+    private getCacheByPath;
+    private getCountByStatus;
     get files(): File[];
-    get tree(): TreeNode<{
-        name: string;
-        path: string;
-        type: "file" | "directory";
-    }>;
-    generateRootFiles(options: GenerateTreeNodeOptions): Promise<void>[];
     add(file: File): Promise<File>;
+    addOrAppend(file: File): Promise<File>;
     setStatus(id: UUID, status: Status): void;
     get(id: UUID): File | undefined;
     remove(id: UUID): void;
+    static writeIndexes(root: string, output: string, options: Parameters<typeof TreeNode.generate>[1]): Promise<void>[];
 }
 
 interface Cache<TCache = any> {
@@ -126,30 +115,36 @@ type KubbConfig = {
      * @default process.cwd()
      */
     root: string;
-    mode?: 'single';
     input: {
         /**
-         * Path or link to the input file
+         * Path to be used as the input. Can be an absolute path, or a path relative from
+         * the defined root option.
          */
         path: string;
     };
     output: {
         /**
-         * Path to export folder
+         * Path to be used to export all generated files. Can be an absolute path, or a path relative from
+         * the defined root option.
          */
         path: string;
+        /**
+         * Remove previous generated files and folders.
+         */
         clean?: boolean;
     };
     /**
      * Array of Kubb plugins to use.
+     * The plugin/package can forsee some options that you need to pass through.
+     * Sometimes a plugin is depended on another plugin, if that's the case you will get an error back from the plugin you installed.
      */
     plugins?: KubbPlugin[];
     /**
-     * Hooks that can be called when a specific action is done in Kubb.
+     * Hooks that will be called when a specific action is triggered in Kubb.
      */
     hooks?: {
         /**
-         * Hook that will be called at the end of all executions.
+         * Hook that will be triggerend at the end of all executions.
          */
         done?: string | string[];
     };
@@ -173,23 +168,55 @@ type PluginFactoryOptions<Options = unknown, Nested extends boolean = false, Api
     api: Api;
 };
 type PluginLifecycle = {
+    /**
+     * Valdiate all plugins to see if their depended plugins are installed and configured.
+     * @type hookParallel
+     */
     validate: (this: PluginContext, plugins: KubbPlugin[]) => MaybePromise<ValidationResult>;
+    /**
+     * Start of the lifecycle of a plugin.
+     * @type hookParallel
+     */
     buildStart: (this: PluginContext, kubbConfig: KubbConfig) => MaybePromise<void>;
-    resolveId: (this: PluginContext, importee: string, importer?: string, options?: Record<string, any>) => Path;
-    load: (this: PluginContext, id: string) => MaybePromise<TransformResult | null>;
-    transform: (this: PluginContext, code: string, id: string) => MaybePromise<TransformResult>;
-    writeFile: (this: PluginContext, code: string | undefined, id: string) => MaybePromise<void>;
+    /**
+     * Resolve to an id based on importee(example: `./Pet.ts`) and directory(example: `./models`).
+     * @type hookFirst
+     * @example ('./Pet.ts', './src/gen/')
+     */
+    resolveId: (this: PluginContext, fileName: string, directory?: string, options?: Record<string, any>) => OptionalPath;
+    /**
+     * Makes it possible to run async logic to override the path defined previously by `resolveId`.
+     * @type hookFirst
+     */
+    load: (this: PluginContext, path: Path) => MaybePromise<TransformResult | null>;
+    /**
+     * Transform the source-code.
+     * @type hookReduceArg0
+     */
+    transform: (this: PluginContext, source: string, path: Path) => MaybePromise<TransformResult>;
+    /**
+     * Write the result to the file-system based on the id(defined by `resolveId` or changed by `load`).
+     * @type hookParallel
+     */
+    writeFile: (this: PluginContext, source: string | undefined, path: Path) => MaybePromise<void>;
+    /**
+     * End of the plugin lifecycle.
+     * @type hookParallel
+     */
     buildEnd: (this: PluginContext) => MaybePromise<void>;
 };
 type PluginLifecycleHooks = keyof PluginLifecycle;
 type ResolveIdParams = {
-    importee: string;
-    importer?: string | undefined;
+    fileName: string;
+    directory?: string | undefined;
     /**
      * 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.
      */
     pluginName?: string;
+    /**
+     * Options to be passed to 'resolveId' 3th parameter
+     */
     options?: Record<string, any>;
 };
 type PluginContext = {
@@ -199,7 +226,7 @@ type PluginContext = {
     addFile: (emitedFile: EmittedFile | File, options?: {
         root?: true;
     }) => Promise<File>;
-    resolveId: (params: ResolveIdParams) => MaybePromise<Path>;
+    resolveId: (params: ResolveIdParams) => MaybePromise<OptionalPath>;
     load: (id: string) => MaybePromise<TransformResult | void>;
 };
 type ValidationResult = true | {
@@ -209,7 +236,8 @@ type TransformResult = string | null;
 /**
  * @description Computing the name of a file or directory together with its position in relation to other directories traced back in a line to the root
  */
-type Path = string | null | undefined;
+type Path = string;
+type OptionalPath = Path | null | undefined;
 type FileName = string | null | undefined;
 type LogType = 'error' | 'warn' | 'info';
 type LogLevel = LogType | 'silent';
@@ -263,6 +291,7 @@ declare const write: (data: string, path: string, options?: WriteOptions) => Pro
 declare const format: (text: string) => string;
 
 declare const getRelativePath: (root?: string | null, file?: string | null) => string;
+declare const getPathMode: (path: string | undefined | null) => "file" | "directory" | undefined;
 
 /**
  * Get the type of the first argument in a function.
@@ -281,7 +310,7 @@ declare class PluginManager {
     constructor(config: KubbConfig, options: {
         logger?: Logger;
     });
-    resolveId: (params: ResolveIdParams) => Promise<Path>;
+    resolveId: (params: ResolveIdParams) => Promise<OptionalPath>;
     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>;
@@ -306,4 +335,4 @@ declare class PluginManager {
     private runSync;
 }
 
-export { Argument0, CLIOptions, Cache, CacheStore, CorePluginOptions, EmittedFile, File, FileManager, FileName, GenerateTreeNodeOptions, KubbConfig, KubbPlugin, KubbUserConfig, LogLevel, LogType, Logger, MaybePromise, Path, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, ResolveIdParams, Status, Strategy, TransformResult, TreeNode, UUID, ValidationResult, build, createPlugin, createPluginCache, build as default, defineConfig, format, getRelativePath, hooks, isPromise, write };
+export { Argument0, CLIOptions, Cache, CacheStore, CorePluginOptions, EmittedFile, File, FileManager, FileName, KubbConfig, KubbPlugin, KubbUserConfig, LogLevel, LogType, Logger, MaybePromise, OptionalPath, Path, PluginContext, PluginFactoryOptions, PluginLifecycle, PluginLifecycleHooks, PluginManager, ResolveIdParams, Status, Strategy, TransformResult, TreeNode, UUID, ValidationResult, build, createPlugin, createPluginCache, build as default, defineConfig, format, getPathMode, getRelativePath, hooks, isPromise, write };

package/dist/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var path3 = require('path');
 var fse = require('fs-extra');
+var pathParser = require('path');
 var prettier = require('prettier');
 var EventEmitter = require('events');
 var crypto = require('crypto');
@@ -29,18 +29,18 @@ var format = (text) => {
 };
 
 // src/utils/write.ts
-var write = async (data, path5, options = { format: false }) => {
+var write = async (data, path, options = { format: false }) => {
   const formattedData = options.format ? format(data) : data;
   try {
-    await fse.stat(path5);
-    const oldContent = await fse.readFile(path5, { encoding: "utf-8" });
+    await fse.stat(path);
+    const oldContent = await fse.readFile(path, { encoding: "utf-8" });
     if (oldContent?.toString() === formattedData) {
       return;
     }
   } catch (_err) {
-    return fse.outputFile(path5, formattedData);
+    return fse.outputFile(path, formattedData);
   }
-  return fse.outputFile(path5, formattedData);
+  return fse.outputFile(path, formattedData);
 };
 
 // src/utils/cache.ts
@@ -72,67 +72,15 @@ var getRelativePath = (root, file) => {
   if (!root || !file) {
     throw new Error("Root and file should be filled in when retrieving the relativePath");
   }
-  const newPath = path3.relative(root, file).replace("../", "").replace(".ts", "").trimEnd();
+  const newPath = pathParser.relative(root, file).replace("../", "").replace(".ts", "").trimEnd();
   return `./${newPath}`;
 };
-
-// src/plugin.ts
-function createPlugin(factory) {
-  return (options) => {
-    const plugin = factory(options);
-    if (Array.isArray(plugin)) {
-      throw new Error("Not implemented");
-    }
-    if (!plugin.transform) {
-      plugin.transform = function transform(code) {
-        return code;
-      };
-    }
-    return plugin;
-  };
-}
-var name = "core";
-var isEmittedFile = (result) => {
-  return !!result.id;
+var getPathMode = (path) => {
+  if (!path) {
+    return void 0;
+  }
+  return pathParser.extname(path) ? "file" : "directory";
 };
-var definePlugin = createPlugin((options) => {
-  const { fileManager, resolveId, load } = options;
-  const api = {
-    get config() {
-      return options.config;
-    },
-    fileManager,
-    async addFile(file, options2) {
-      if (isEmittedFile(file)) {
-        const resolvedId = await resolveId({ importee: file.id, importer: file.importer, options: file.options });
-        const filePath = resolvedId || file.importer || file.id;
-        return fileManager.add({
-          path: filePath,
-          fileName: file.name || file.id,
-          source: file.source || ""
-        });
-      }
-      if (options2?.root) ;
-      return fileManager.add(file);
-    },
-    resolveId,
-    load,
-    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
-  };
-  return {
-    name,
-    api,
-    async buildEnd() {
-      await this.fileManager.generateRootFiles({ exclude: [/schemas/, /json/] });
-    },
-    resolveId(importee, importer) {
-      if (!importer) {
-        return null;
-      }
-      return path3.resolve(importer, importee);
-    }
-  };
-});
 
 // src/managers/fileManager/events.ts
 var keys = {
@@ -242,8 +190,8 @@ var TreeNode = class {
     }
     return this;
   }
-  static generate(path5, options = {}) {
-    const filteredTree = dirTree(path5, { extensions: options?.extensions, exclude: options.exclude });
+  static generate(path, options = {}) {
+    const filteredTree = dirTree(path, { extensions: options?.extensions, exclude: options.exclude });
     const treeNode = new TreeNode({ name: filteredTree.name, path: filteredTree.path, type: filteredTree.type });
     const recurse = (node, item) => {
       const subNode = node.addChild({ name: item.name, path: item.path, type: item.type });
@@ -261,15 +209,11 @@ var TreeNode = class {
 // src/managers/fileManager/FileManager.ts
 var FileManager = class {
   cache = /* @__PURE__ */ new Map();
-  root;
-  output;
   emitter = new EventEmitter();
   events = getFileManagerEvents(this.emitter);
-  constructor(options = {}) {
-    this.root = path3.resolve(options.root || ".");
-    this.output = options?.output || process.cwd();
+  constructor() {
     this.events.onStatusChange(() => {
-      if (this.getCountOfStatus("removed") === this.cache.size) {
+      if (this.getCountByStatus("removed") === this.cache.size) {
         this.events.emitSuccess();
       }
     });
@@ -277,7 +221,16 @@ var FileManager = class {
   getCache(id) {
     return this.cache.get(id);
   }
-  getCountOfStatus(status) {
+  getCacheByPath(path) {
+    let cache;
+    this.cache.forEach((item) => {
+      if (item.file.path === path) {
+        cache = item;
+      }
+    });
+    return cache;
+  }
+  getCountByStatus(status) {
     let count = 0;
     this.cache.forEach((item) => {
       if (item.status === status) {
@@ -293,34 +246,81 @@ var FileManager = class {
     });
     return files;
   }
-  get tree() {
-    return TreeNode.generate(this.output, { extensions: /\.ts/ });
+  add(file) {
+    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
+    this.cache.set(cacheItem.id, cacheItem);
+    this.events.emitFile(cacheItem.id, file);
+    return new Promise((resolve) => {
+      const unsubscribe = this.events.onRemove(cacheItem.id, (file2) => {
+        resolve(file2);
+        unsubscribe();
+      });
+    });
+  }
+  addOrAppend(file) {
+    const previousCache = this.getCacheByPath(file.path);
+    if (previousCache) {
+      this.remove(previousCache.id);
+      return this.add({
+        ...file,
+        source: `${previousCache.file.source}
+${file.source}`
+      });
+    }
+    return this.add(file);
+  }
+  setStatus(id, status) {
+    const cacheItem = this.getCache(id);
+    if (!cacheItem) {
+      return;
+    }
+    cacheItem.status = status;
+    this.cache.set(id, cacheItem);
+    this.events.emitStatusChange(cacheItem.file);
+    this.events.emitStatusChangeById(id, status);
+  }
+  get(id) {
+    const cacheItem = this.getCache(id);
+    return cacheItem?.file;
+  }
+  remove(id) {
+    const cacheItem = this.getCache(id);
+    if (!cacheItem) {
+      return;
+    }
+    this.setStatus(id, "removed");
+    this.events.emitRemove(id, cacheItem.file);
   }
-  generateRootFiles(options) {
-    const tree = TreeNode.generate(this.output, { extensions: /\.ts/, ...options });
+  static writeIndexes(root, output, options) {
+    const tree = TreeNode.generate(output, { extensions: /\.ts/, ...options });
     const fileReducer = (files2, item) => {
       if (!item.children) {
         return [];
       }
       if (item.children?.length > 1) {
+        const path = pathParser.resolve(root, item.data.path, "index.ts");
         const source = item.children.reduce((source2, file) => {
           if (!file) {
             return source2;
           }
           const importPath = file.data.type === "directory" ? `./${file.data.name}` : `./${file.data.name.replace(/\.[^.]*$/, "")}`;
+          if (importPath.includes("index") && path.includes("index")) {
+            return source2;
+          }
           return `${source2}export * from "${importPath}";
 `;
         }, "");
         files2.push({
-          path: path3.resolve(this.root, item.data.path, "index.ts"),
+          path,
           fileName: "index.ts",
           source
         });
       } else {
         item.children?.forEach((child) => {
+          const path = pathParser.resolve(root, item.data.path, "index.ts");
           const importPath = child.data.type === "directory" ? `./${child.data.name}` : `./${child.data.name.replace(/\.[^.]*$/, "")}`;
           files2.push({
-            path: path3.resolve(this.root, item.data.path, "index.ts"),
+            path,
             fileName: "index.ts",
             source: `export * from "${importPath}";
 `
@@ -335,40 +335,65 @@ var FileManager = class {
     const files = fileReducer([], tree);
     return files.map((file) => write(file.source, file.path));
   }
-  add(file) {
-    const cacheItem = { id: crypto.randomUUID(), file, status: "new" };
-    this.cache.set(cacheItem.id, cacheItem);
-    this.events.emitFile(cacheItem.id, file);
-    return new Promise((resolve) => {
-      const unsubscribe = this.events.onRemove(cacheItem.id, (file2) => {
-        resolve(file2);
-        unsubscribe();
-      });
-    });
-  }
-  setStatus(id, status) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
+};
+
+// src/plugin.ts
+function createPlugin(factory) {
+  return (options) => {
+    const plugin = factory(options);
+    if (Array.isArray(plugin)) {
+      throw new Error("Not implemented");
     }
-    cacheItem.status = status;
-    this.cache.set(id, cacheItem);
-    this.events.emitStatusChange(cacheItem.file);
-    this.events.emitStatusChangeById(id, status);
-  }
-  get(id) {
-    const cacheItem = this.getCache(id);
-    return cacheItem?.file;
-  }
-  remove(id) {
-    const cacheItem = this.getCache(id);
-    if (!cacheItem) {
-      return;
+    if (!plugin.transform) {
+      plugin.transform = function transform(code) {
+        return code;
+      };
     }
-    this.setStatus(id, "removed");
-    this.events.emitRemove(id, cacheItem.file);
-  }
+    return plugin;
+  };
+}
+var name = "core";
+var isEmittedFile = (result) => {
+  return !!result.id;
 };
+var definePlugin = createPlugin((options) => {
+  const { fileManager, resolveId, load } = options;
+  const api = {
+    get config() {
+      return options.config;
+    },
+    fileManager,
+    async addFile(file, options2) {
+      if (isEmittedFile(file)) {
+        const resolvedId = await resolveId({ fileName: file.id, directory: file.importer, options: file.options });
+        const path = resolvedId || file.importer || file.id;
+        return fileManager.add({
+          path,
+          fileName: file.name || file.id,
+          source: file.source || ""
+        });
+      }
+      if (options2?.root) ;
+      return fileManager.addOrAppend(file);
+    },
+    resolveId,
+    load,
+    cache: createPluginCache(/* @__PURE__ */ Object.create(null))
+  };
+  return {
+    name,
+    api,
+    async buildEnd() {
+      await FileManager.writeIndexes(this.config.root, this.config.output.path, { exclude: [/schemas/, /json/] });
+    },
+    resolveId(fileName, directory) {
+      if (!directory) {
+        return null;
+      }
+      return pathParser.resolve(directory, fileName);
+    }
+  };
+});
 
 // src/managers/pluginManager/PluginManager.ts
 var hookNames = {
@@ -390,7 +415,7 @@ var PluginManager = class {
   constructor(config, options) {
     this.logger = options.logger;
     this.config = config;
-    this.fileManager = new FileManager({ root: this.config.root, output: this.config.output.path });
+    this.fileManager = new FileManager();
     this.core = definePlugin({
       config,
       fileManager: this.fileManager,
@@ -401,9 +426,9 @@ var PluginManager = class {
   }
   resolveId = (params) => {
     if (params.pluginName) {
-      return this.hookForPlugin(params.pluginName, "resolveId", [params.importee, params.importer, params.options]);
+      return this.hookForPlugin(params.pluginName, "resolveId", [params.fileName, params.directory, params.options]);
     }
-    return this.hookFirst("resolveId", [params.importee, params.importer, params.options]);
+    return this.hookFirst("resolveId", [params.fileName, params.directory, params.options]);
   };
   load = async (id) => {
     return this.hookFirst("load", [id]);
@@ -533,7 +558,6 @@ async function buildImplementation(options, done) {
   }
   const pluginManager = new PluginManager(config, { logger });
   const { plugins, fileManager } = pluginManager;
-  fse.readFileSync(path3.resolve(config.root, config.input.path), "utf-8");
   const validations = await pluginManager.hookParallel("validate", [plugins]);
   const validationsWithMessage = validations.filter(Boolean);
   if (validationsWithMessage.some((validation) => typeof validation !== "boolean")) {
@@ -551,15 +575,15 @@ async function buildImplementation(options, done) {
     }, 1e3);
   });
   fileManager.events.onAdd(async (id, file) => {
-    const { path: filePath } = file;
+    const { path } = file;
     let { source: code } = file;
-    const loadedResult = await pluginManager.hookFirst("load", [filePath]);
+    const loadedResult = await pluginManager.hookFirst("load", [path]);
     if (loadedResult) {
       code = loadedResult;
     }
     if (code) {
-      const transformedCode = await pluginManager.hookReduceArg0("transform", [code, filePath], transformReducer);
-      await pluginManager.hookParallel("writeFile", [transformedCode, filePath]);
+      const transformedCode = await pluginManager.hookReduceArg0("transform", [code, path], transformReducer);
+      await pluginManager.hookParallel("writeFile", [transformedCode, path]);
       fileManager.setStatus(id, "success");
       fileManager.remove(id);
     }
@@ -591,6 +615,7 @@ exports.createPluginCache = createPluginCache;
 exports.default = src_default;
 exports.defineConfig = defineConfig;
 exports.format = format;
+exports.getPathMode = getPathMode;
 exports.getRelativePath = getRelativePath;
 exports.hooks = hooks;
 exports.isPromise = isPromise;