node-pluginsmanager 3.6.2 → 3.7.0

package/README.md

@@ -48,23 +48,27 @@ $ npm install node-pluginsmanager
 
   * ``` on("error", (err: Error) => void) : this ``` fires if an error occurs
 
-  * ``` on("loading", (plugin: Orchestrator, data?: any) => void) : this ``` fires if a plugin starts load
-  * ``` on("loaded", (plugin: Orchestrator, data?: any) => void) : this ``` fires if a plugin ends load
-  * ``` on("allloaded", (data?: any) => void) : this ``` fires if all the plugins are loaded
+  * ``` on("loading", (pluginName: string, ...unknown[]) => void) : this ``` fires if a plugin starts load
+  * ``` on("loaded", (plugin: Orchestrator, ...unknown[]) => void) : this ``` fires if a plugin ends load
+  * ``` on("allloaded", (...unknown[]) => void) : this ``` fires if all the plugins are loaded
 
-  * ``` on("initializing", (plugin: Orchestrator, data?: any) => void) : this ``` fires if a plugin starts init
-  * ``` on("initialized", (plugin: Orchestrator, data?: any) => void) : this ``` fires if a plugin ends init
-  * ``` on("allinitialized", (data?: any) => void) : this ``` fires if all the plugins are initialized
+  * ``` on("initializing", (plugin: Orchestrator, ...unknown[]) => void) : this ``` fires if a plugin starts init
+  * ``` on("initialized", (plugin: Orchestrator, ...unknown[]) => void) : this ``` fires if a plugin ends init
+  * ``` on("allinitialized", (...unknown[]) => void) : this ``` fires if all the plugins are initialized
 
-  * ``` on("released", (plugin: Orchestrator, data?: any) => void) : this ``` fires if a plugin is released
-  * ``` on("allreleased", (data?: any) => void) : this ``` fires if all the plugins are released
+  * ``` on("released", (plugin: Orchestrator, ...unknown[]) => void) : this ``` fires if a plugin is released
+  * ``` on("allreleased", (...unknown[]) => void) : this ``` fires if all the plugins are released
 
-  * ``` on("destroyed", (pluginName: string, data?: any) => void) : this ``` fires if a plugin is destroyed
-  * ``` on("alldestroyed", (data?: any) => void) : this ``` fires if all the plugins are destroyed
+  * ``` on("destroyed", (pluginName: string, ...unknown[]) => void) : this ``` fires if a plugin is destroyed
+  * ``` on("alldestroyed", (...unknown[]) => void) : this ``` fires if all the plugins are destroyed
 
-  * ``` on("installed", (pluginName: string, data?: any) => void) : this ``` fires if a plugin is installed
-  * ``` on("updated", (plugin: Orchestrator, data?: any) => void) : this ``` fires if a plugin is updated
-  * ``` on("uninstalled", (pluginName: string, data?: any) => void) : this ``` fires if a plugin is uninstalled
+  * ``` on("installing", (pluginName: string, currentStep: number, maxSteps: number, stepDescription: string, ...unknown[]) => void) : this ``` fires with plugin installation progress
+  * ``` on("installed", (plugin: Orchestrator, ...unknown[]) => void) : this ``` fires if a plugin is installed
+
+  * ``` on("updating", (pluginName: string, currentStep: number, maxSteps: number, stepDescription: string, ...unknown[]) => void) : this ``` fires with plugin update progress
+  * ``` on("updated", (plugin: Orchestrator, ...unknown[]) => void) : this ``` fires if a plugin is updated
+
+  * ``` on("uninstalled", (pluginName: string, ...unknown[]) => void) : this ``` fires if a plugin is uninstalled
 
 ## Examples
 

package/lib/cjs/PluginsManager.d.ts

@@ -9,7 +9,23 @@ interface iPluginManagerOptions {
     "logger"?: tLogger | null;
 }
 type tBeforeAllMethodCallback = (...data: unknown[]) => Promise<void> | void;
-export default class PluginsManager extends EventEmitter {
+export default class PluginsManager extends EventEmitter<{
+    "loading": [string, ...unknown[]];
+    "loaded": [Orchestrator, ...unknown[]];
+    "allloaded": [...unknown[]];
+    "initializing": [Orchestrator, ...unknown[]];
+    "initialized": [Orchestrator, ...unknown[]];
+    "allinitialized": [...unknown[]];
+    "released": [Orchestrator, ...unknown[]];
+    "allreleased": [...unknown[]];
+    "destroyed": [string, ...unknown[]];
+    "alldestroyed": [...unknown[]];
+    "installing": [string, number, number, string, ...unknown[]];
+    "installed": [Orchestrator, ...unknown[]];
+    "updating": [string, number, number, string, ...unknown[]];
+    "updated": [Orchestrator, ...unknown[]];
+    "uninstalled": [string, ...unknown[]];
+}> {
     protected _beforeLoadAll: tBeforeAllMethodCallback | null;
     protected _beforeInitAll: tBeforeAllMethodCallback | null;
     protected _logger: tLogger | null;
@@ -33,6 +49,7 @@ export default class PluginsManager extends EventEmitter {
     releaseAll(...data: unknown[]): Promise<void>;
     getLatestGithubTag(plugin: Orchestrator): Promise<string>;
     installViaGithub(user: string, repo: string, ...data: unknown[]): Promise<Orchestrator>;
+    private _updateWithoutGit;
     updateViaGithub(plugin: Orchestrator, ...data: unknown[]): Promise<Orchestrator>;
     uninstall(plugin: Orchestrator, ...data: unknown[]): Promise<string>;
 }

package/lib/cjs/PluginsManager.js

@@ -27,6 +27,7 @@ const loadSortedPlugins_1 = __importDefault(require("./loadSortedPlugins"));
 const initSortedPlugins_1 = __importDefault(require("./initSortedPlugins"));
 const getLatestGithubTag_1 = __importDefault(require("./utils/getLatestGithubTag"));
 const parseGithubUserRepo_1 = __importDefault(require("./utils/parseGithubUserRepo"));
+const isGitUsed_1 = __importDefault(require("./cmd/isGitUsed"));
 // git
 const gitInstall_1 = __importDefault(require("./cmd/git/gitInstall"));
 const gitUpdate_1 = __importDefault(require("./cmd/git/gitUpdate"));
@@ -222,8 +223,9 @@ class PluginsManager extends node_events_1.default {
     // after releasing, destroy packages data & free "plugins" list, using "data" in arguments for "destroy" plugin's Orchestrator method
     destroyAll(...data) {
         return Promise.all(this.plugins.map((plugin) => {
+            const pluginName = plugin.name;
             return plugin.destroy(...data).then(() => {
-                this.emit("destroyed", plugin.name, ...data);
+                this.emit("destroyed", pluginName, ...data);
             });
         })).then(() => {
             this.plugins = [];
@@ -282,15 +284,17 @@ class PluginsManager extends node_events_1.default {
     }
     // install a plugin via github repo, using "data" in arguments for "install" and "init" plugin's Orchestrator methods
     installViaGithub(user, repo, ...data) {
+        const MAX_INSTALL_STEPS = 10;
+        let pluginName = repo;
         return (0, checkAbsoluteDirectory_1.default)("installViaGithub/directory", this.directory).then(() => {
             return (0, checkNonEmptyString_1.default)("installViaGithub/user", user);
         }).then(() => {
-            return (0, checkNonEmptyString_1.default)("installViaGithub/repo", repo);
+            return (0, checkNonEmptyString_1.default)("installViaGithub/repo", pluginName);
         }).then(() => {
-            const directory = (0, node_path_1.join)(this.directory, repo);
+            const directory = (0, node_path_1.join)(this.directory, pluginName);
             return new Promise((resolve, reject) => {
                 (0, checkAbsoluteDirectory_1.default)("installViaGithub/plugindirectory", directory).then(() => {
-                    return reject(new Error("\"" + repo + "\" plugin already exists"));
+                    return reject(new Error("\"" + pluginName + "\" plugin already exists"));
                 }).catch(() => {
                     return resolve(directory);
                 });
@@ -298,15 +302,16 @@ class PluginsManager extends node_events_1.default {
         }).then((directory) => {
             // download plugin
             return Promise.resolve().then(() => {
-                this._logger?.("info", "Downloading plugin...", false, repo);
-                return (0, gitInstall_1.default)(directory, user, repo).then(() => {
-                    this._logger?.("success", "Download success", false, repo);
+                this._logger?.("info", "Downloading plugin...", false, pluginName);
+                this.emit("installing", pluginName, 1, MAX_INSTALL_STEPS, "Downloading plugin...");
+                return (0, gitInstall_1.default)(directory, user, pluginName).then(() => {
+                    this._logger?.("success", "Download success", false, pluginName);
                 });
                 // check if plugin directory is created
             }).then(() => {
                 return (0, isDirectory_1.default)(directory).then((isPluginADirectory) => {
                     if (!isPluginADirectory) {
-                        throw new Error("\"" + repo + "\" plugin directory is not created");
+                        throw new Error("\"" + pluginName + "\" plugin directory is not created");
                     }
                 });
                 // work around package.json
@@ -315,22 +320,24 @@ class PluginsManager extends node_events_1.default {
                 // check if plugin has a valid package.json
                 return (0, isFile_1.default)(packageFile).then((isPluginAPackageFile) => {
                     if (!isPluginAPackageFile) {
-                        throw new Error("\"" + repo + "\" plugin has no valid package.json");
+                        throw new Error("\"" + pluginName + "\" plugin has no valid package.json");
                     }
                     // read package.json and parse it
                 }).then(() => {
+                    this._logger?.("debug", "Reading package.json...", false, pluginName);
+                    this.emit("installing", pluginName, 2, MAX_INSTALL_STEPS, "Reading package.json...");
                     return (0, promises_1.readFile)(packageFile, "utf-8").then((content) => {
                         return JSON.parse(content);
                     });
                 }).then((packageData) => {
                     // check if the plugin has a valid name
                     if ("string" !== typeof packageData.name || "" === packageData.name.trim()) {
-                        throw new Error("\"" + repo + "\" plugin has no valid name");
+                        throw new Error("\"" + pluginName + "\" plugin has no valid name");
                     }
-                    const pluginName = packageData.name;
+                    pluginName = packageData.name;
                     // check if the plugin has a valid entry point
                     if ("string" !== typeof packageData.main || "" === packageData.main.trim()) {
-                        throw new Error("\"" + repo + "\" plugin has no valid entry point");
+                        throw new Error("\"" + pluginName + "\" plugin has no valid entry point");
                     }
                     const entryPoint = (0, node_path_1.join)(directory, packageData.main);
                     // check if the plugin is builded (build it if needed)
@@ -341,21 +348,24 @@ class PluginsManager extends node_events_1.default {
                         }
                         // check if the plugin has a build script
                         if ("object" !== typeof packageData.scripts || null === packageData.scripts || 0 >= Object.keys(packageData.scripts).length) {
-                            throw new Error("\"" + repo + "\" plugin has no scripts registered");
+                            throw new Error("\"" + pluginName + "\" plugin has no scripts registered");
                         }
                         const scripts = packageData.scripts;
                         if ("string" !== typeof scripts.build || "" === scripts.build.trim()) {
-                            throw new Error("\"" + repo + "\" plugin has no build script registered");
+                            throw new Error("\"" + pluginName + "\" plugin has no build script registered");
                         }
                         this._logger?.("info", "Installing dev dependencies...", false, pluginName);
+                        this.emit("installing", pluginName, 3, MAX_INSTALL_STEPS, "Installing dev dependencies...");
                         // install plugin with dependencies
                         return (0, npmInstall_1.default)(directory, true).then(() => {
                             this._logger?.("success", "Plugin installed successfully", false, pluginName);
                             this._logger?.("info", "Building plugin...", false, pluginName);
+                            this.emit("installing", pluginName, 4, MAX_INSTALL_STEPS, "Building plugin...");
                             return (0, npmBuild_1.default)(directory);
                             // remove dev dependencies
                         }).then(() => {
                             this._logger?.("debug", "Removing dev dependencies...", false, pluginName);
+                            this.emit("installing", pluginName, 5, MAX_INSTALL_STEPS, "Removing dev dependencies...");
                             return (0, rmdirp_1.default)((0, node_path_1.join)(directory, "node_modules")).then(() => {
                                 this._logger?.("success", "Dev dependencies removed successfully", false, pluginName);
                             });
@@ -364,7 +374,8 @@ class PluginsManager extends node_events_1.default {
                         if ("object" !== typeof packageData.dependencies || null === packageData.dependencies || 0 >= Object.keys(packageData.dependencies).length) {
                             return Promise.resolve();
                         }
-                        this._logger?.("debug", "Installing dependencies...", false, pluginName);
+                        this._logger?.("debug", "Installing plugin dependencies...", false, pluginName);
+                        this.emit("installing", pluginName, 6, MAX_INSTALL_STEPS, "Installing plugin dependencies...");
                         return (0, npmInstall_1.default)(directory).then(() => {
                             this._logger?.("success", "Dependencies installed successfully", false, pluginName);
                         });
@@ -372,20 +383,28 @@ class PluginsManager extends node_events_1.default {
                 });
                 // create plugin
             }).then(() => {
+                this._logger?.("debug", "Creating plugin...", false, pluginName);
+                this.emit("installing", pluginName, 7, MAX_INSTALL_STEPS, "Creating plugin...");
                 return (0, createPluginByDirectory_1.default)(directory, this.externalResourcesDirectory, this._logger, ...data);
                 // check plugin modules versions
             }).then((plugin) => {
+                this._logger?.("debug", "Checking plugin modules versions...", false, pluginName);
+                this.emit("installing", pluginName, 8, MAX_INSTALL_STEPS, "Checking plugin modules versions...");
                 return this.checkModules(plugin).then(() => {
                     return Promise.resolve(plugin);
                 });
             }).then((plugin) => {
                 // execute plugin install script
                 return Promise.resolve().then(() => {
+                    this._logger?.("debug", "Executing plugin install script...", false, pluginName);
+                    this.emit("installing", pluginName, 9, MAX_INSTALL_STEPS, "Executing plugin install script...");
                     return plugin.install(...data).then(() => {
                         this.emit("installed", plugin, ...data);
                     });
                     // execute init plugin script
                 }).then(() => {
+                    this._logger?.("debug", "Executing plugin init script...", false, pluginName);
+                    this.emit("installing", pluginName, 10, MAX_INSTALL_STEPS, "Executing plugin init script...");
                     return plugin.init(...data).then(() => {
                         this.emit("initialized", plugin, ...data);
                         this.plugins.push(plugin);
@@ -409,18 +428,29 @@ class PluginsManager extends node_events_1.default {
             });
         });
     }
+    _updateWithoutGit(directory, githubRepository) {
+        return (0, promises_1.rm)(directory, {
+            "recursive": true,
+            "force": true
+        }).then(() => {
+            const githubUserRepo = (0, parseGithubUserRepo_1.default)(githubRepository);
+            if (!githubUserRepo) {
+                throw new Error("Plugin has an invalid github project link");
+            }
+            const { user, repo } = githubUserRepo;
+            return (0, gitInstall_1.default)(directory, user, repo);
+        });
+    }
     // update a plugin via its github repo, using "data" in arguments for "release", "update" and "init" plugin's methods
     updateViaGithub(plugin, ...data) {
         let directory = "";
-        let key = -1;
         let pluginName = "";
+        let githubRepository = "";
         // check plugin
         return (0, checkOrchestrator_1.default)("updateViaGithub/plugin", plugin).then(() => {
             pluginName = plugin.name;
-            key = this.getPluginsNames().findIndex((pn) => {
-                return pluginName === pn;
-            });
-            if (-1 >= key) {
+            githubRepository = plugin.repository;
+            if (!this.getPluginsNames().includes(pluginName)) {
                 throw new Error("Plugin \"" + pluginName + "\" is not registered");
             }
             // check plugin directory
@@ -429,61 +459,84 @@ class PluginsManager extends node_events_1.default {
                 directory = (0, node_path_1.join)(this.directory, pluginName);
                 return (0, checkAbsoluteDirectory_1.default)("updateViaGithub/plugindirectory", directory);
             });
-            // check remote version
         }).then(() => {
-            const currentVersion = semver_1.default.coerce(plugin.version);
-            if (!currentVersion) {
-                throw new Error("Plugin \"" + pluginName + "\" has no valid version (\"" + plugin.version + "\")");
-            }
-            this._logger?.("debug", "Get github latest tag", false, pluginName);
-            return this.getLatestGithubTag(plugin).then((tag) => {
-                const latestVersion = semver_1.default.coerce(tag);
-                if (!latestVersion) {
-                    throw new Error("No valid version found for plugin \"" + pluginName + "\" on github");
-                }
-                this._logger?.("debug", "Compare local version with github latest tag", false, pluginName);
-                if (!semver_1.default.gt(latestVersion, currentVersion)) {
-                    throw new Error("Plugin \"" + pluginName + "\" is already up to date (v" + plugin.version + ")");
+            return (0, isGitUsed_1.default)(directory);
+        }).then((gitUsed) => {
+            const MAX_UPDATE_STEPS = 7;
+            // check remote version
+            return Promise.resolve().then(() => {
+                const currentVersion = semver_1.default.coerce(plugin.version);
+                if (!currentVersion) {
+                    throw new Error("Plugin \"" + pluginName + "\" has no valid version (\"" + plugin.version + "\")");
                 }
-                this._logger?.("success", "New version available", false, pluginName);
-                return tag;
-            });
-            // release plugin
-        }).then((latestTag) => {
-            return plugin.release(...data).then(() => {
-                this.emit("released", plugin, ...data);
-                return plugin.destroy(...data);
+                this._logger?.("debug", "Get github latest tag", false, pluginName);
+                this.emit("updating", pluginName, 1, MAX_UPDATE_STEPS, "Getting github latest tag...");
+                return this.getLatestGithubTag(plugin).then((tag) => {
+                    const latestVersion = semver_1.default.coerce(tag);
+                    if (!latestVersion) {
+                        throw new Error("No valid version found for plugin \"" + pluginName + "\" on github");
+                    }
+                    this._logger?.("debug", "Compare local version with github latest tag", false, pluginName);
+                    if (!semver_1.default.gt(latestVersion, currentVersion)) {
+                        throw new Error("Plugin \"" + pluginName + "\" is already up to date (v" + plugin.version + ")");
+                    }
+                    this._logger?.("success", "New version available", false, pluginName);
+                    return tag;
+                });
+                // release plugin
+            }).then((latestTag) => {
+                this._logger?.("debug", "Releasing plugin...", false, pluginName);
+                this.emit("updating", pluginName, 2, MAX_UPDATE_STEPS, "Releasing plugin...");
+                const key = this.plugins.indexOf(plugin);
+                return plugin.release(...data).then(() => {
+                    this.emit("released", plugin, ...data);
+                    return plugin.destroy(...data);
+                }).then(() => {
+                    this.emit("destroyed", pluginName, ...data);
+                    if (-1 < key) {
+                        this.plugins.splice(key, 1);
+                    }
+                    return latestTag;
+                });
+                // update plugin
+            }).then((latestTag) => {
+                this._logger?.("debug", "Update with new plugin version", false, pluginName);
+                this.emit("updating", pluginName, 3, MAX_UPDATE_STEPS, "Updating plugin with new version...");
+                return gitUsed
+                    ? (0, gitUpdate_1.default)(directory, latestTag)
+                    : this._updateWithoutGit(directory, githubRepository);
+                // after update, create plugin
             }).then(() => {
-                this.emit("destroyed", pluginName, ...data);
-                this.plugins.splice(key, 1);
-                return latestTag;
-            });
-            // update plugin
-        }).then((latestTag) => {
-            this._logger?.("debug", "Update with new plugin version", false, pluginName);
-            return (0, gitUpdate_1.default)(directory, latestTag).then(() => {
+                this._logger?.("debug", "Creating plugin...", false, pluginName);
+                this.emit("updating", pluginName, 4, MAX_UPDATE_STEPS, "Creating plugin...");
                 return (0, createPluginByDirectory_1.default)(directory, this.externalResourcesDirectory, this._logger, ...data);
-            });
-            // check plugin modules versions
-        }).then((_plugin) => {
-            this._logger?.("debug", "Check modules", false, pluginName);
-            return this.checkModules(_plugin).then(() => {
-                return _plugin;
-            });
-        }).then((_plugin) => {
-            // update dependencies & execute update script
-            return Promise.resolve().then(() => {
-                return !_plugin.dependencies ? Promise.resolve() : (0, npmUpdate_1.default)(directory);
-            }).then(() => {
-                return _plugin.update(...data);
-            }).then(() => {
-                this.emit("updated", _plugin, ...data);
-                return _plugin.init(...data);
-                // execute init script
-            }).then(() => {
-                this.emit("initialized", _plugin, ...data);
-                this.plugins[key] = _plugin;
-                return _plugin;
+                // check plugin modules versions
+            }).then((_plugin) => {
+                this._logger?.("debug", "Check modules", false, pluginName);
+                return this.checkModules(_plugin).then(() => {
+                    return _plugin;
+                });
+            }).then((_plugin) => {
+                // update dependencies & execute update script
+                return Promise.resolve().then(() => {
+                    this._logger?.("debug", "Updating dependencies...", false, pluginName);
+                    this.emit("updating", pluginName, 5, MAX_UPDATE_STEPS, "Updating dependencies...");
+                    return !_plugin.dependencies ? Promise.resolve() : (0, npmUpdate_1.default)(directory);
+                }).then(() => {
+                    this._logger?.("debug", "Executing plugin update script...", false, pluginName);
+                    this.emit("updating", pluginName, 6, MAX_UPDATE_STEPS, "Executing plugin update script...");
+                    return _plugin.update(...data);
+                }).then(() => {
+                    this._logger?.("debug", "Executing plugin init script...", false, pluginName);
+                    this.emit("updating", pluginName, 7, MAX_UPDATE_STEPS, "Executing plugin init script...");
+                    this.emit("updated", _plugin, ...data);
+                    return _plugin.init(...data);
+                    // execute init script
+                }).then(() => {
+                    this.emit("initialized", _plugin, ...data);
+                    this.plugins.push(_plugin);
+                    return _plugin;
+                });
             });
         });
     }
@@ -507,9 +560,7 @@ class PluginsManager extends node_events_1.default {
             });
             // release plugin
         }).then(() => {
-            const key = this.getPluginsNames().findIndex((name) => {
-                return name === pluginName;
-            });
+            const key = this.plugins.indexOf(plugin);
             return plugin.release(...data).then(() => {
                 return (0, rmdirp_1.default)((0, node_path_1.join)(this.externalResourcesDirectory, pluginName));
             }).then(() => {
@@ -517,7 +568,9 @@ class PluginsManager extends node_events_1.default {
                 return plugin.destroy(...data);
             }).then(() => {
                 this.emit("destroyed", pluginName, ...data);
-                this.plugins.splice(key, 1);
+                if (-1 < key) {
+                    this.plugins.splice(key, 1);
+                }
             });
             // update dependencies & execute update script
         }).then(() => {

package/lib/cjs/cmd/isGitUsed.d.ts

@@ -0,0 +1 @@
+export default function isGitUsed(directory: string): Promise<boolean>;

package/lib/cjs/cmd/isGitUsed.js

@@ -0,0 +1,32 @@
+"use strict";
+// deps
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isGitUsed;
+// natives
+const node_path_1 = require("node:path");
+// locals
+const cmd_1 = __importDefault(require("./cmd"));
+const isDirectory_1 = __importDefault(require("../utils/isDirectory"));
+// module
+function isGitUsed(directory) {
+    return (0, isDirectory_1.default)((0, node_path_1.join)(directory, ".git")).then((check) => {
+        if (!check) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            (0, cmd_1.default)(directory, "git", [
+                "rev-parse",
+                "-q",
+                "--verify",
+                "HEAD"
+            ]).then(() => {
+                resolve(true);
+            }).catch(() => {
+                resolve(false);
+            });
+        });
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 
   "name": "node-pluginsmanager",
-  "version": "3.6.2",
+  "version": "3.7.0",
   "description": "A plugins manager.",
 
   "type": "commonjs",
@@ -53,7 +53,7 @@
   },
   "devDependencies": {
     "@types/express": "5.0.6",
-    "@types/node": "26.1.0",
+    "@types/node": "26.1.1",
     "@types/semver": "7.7.1",
     "@types/socket.io": "3.0.2",
     "@types/ws": "8.18.1",