@node-red/registry 3.0.0-beta.2 → 3.0.0

package/lib/externalModules.js

@@ -11,6 +11,7 @@ const exec = require("@node-red/util").exec;
 const log = require("@node-red/util").log;
 const hooks = require("@node-red/util").hooks;
 const url = require("url");
+const { createRequire } = require("module");
 
 const BUILTIN_MODULES = require('module').builtinModules;
 
@@ -139,10 +140,15 @@ function importModule(module) {
     }
     const externalModuleDir = getInstallDir();
     const moduleDir = path.join(externalModuleDir,"node_modules",module);
+    // To handle both CJS and ESM we need to resolve the module to the
+    // specific file that is loaded when the module is required/imported
+    // As this won't be on the natural module search path, we use createRequire
+    // to access the module
+    const modulePath = createRequire(moduleDir).resolve(module)
     // Import needs the full path to the module's main .js file
     // It also needs to be a file:// url for Windows
-    const moduleFile = url.pathToFileURL(require.resolve(moduleDir));
-    return import(moduleFile);
+    const moduleUrl = url.pathToFileURL(modulePath);
+    return import(moduleUrl);
 }
 
 function parseModuleName(module) {

package/lib/loader.js

@@ -359,6 +359,7 @@ function loadNodeSet(node) {
     try {
         var loadPromise = null;
         var r = require(node.file);
+        r = r.__esModule ? r.default : r
         if (typeof r === "function") {
 
             var red = registryUtil.createNodeApi(node);

package/lib/localfilesystem.js

@@ -88,9 +88,10 @@ function getLocalFile(file) {
 /**
  * Synchronously walks the directory looking for node files.
  * @param dir the directory to search
+ * @param skipValidNodeRedModules a flag to skip lading icons & files if the directory a valid node-red module
  * @return an array of fully-qualified paths to .js files
  */
-function getLocalNodeFiles(dir) {
+function getLocalNodeFiles(dir, skipValidNodeRedModules) {
     dir = path.resolve(dir);
 
     var result = [];
@@ -102,6 +103,14 @@ function getLocalNodeFiles(dir) {
         return {files: [], icons: []};
     }
     files.sort();
+    // when loading local files, if the path is a valid node-red module
+    // dont include it (will be picked up in scanTreeForNodesModules)
+    if(skipValidNodeRedModules && files.indexOf("package.json") >= 0) {
+        const package = getPackageDetails(dir)
+        if(package.isNodeRedModule) {
+            return {files: [], icons: []};
+        }
+    }
     files.forEach(function(fn) {
         var stats = fs.statSync(path.join(dir,fn));
         if (stats.isFile()) {
@@ -114,7 +123,7 @@ function getLocalNodeFiles(dir) {
         } else if (stats.isDirectory()) {
             // Ignore /.dirs/, /lib/ /node_modules/
             if (!/^(\..*|lib|icons|node_modules|test|locales)$/.test(fn)) {
-                var subDirResults = getLocalNodeFiles(path.join(dir,fn));
+                var subDirResults = getLocalNodeFiles(path.join(dir,fn), skipValidNodeRedModules);
                 result = result.concat(subDirResults.files);
                 icons = icons.concat(subDirResults.icons);
             } else if (fn === "icons") {
@@ -126,21 +135,30 @@ function getLocalNodeFiles(dir) {
     return {files: result, icons: icons}
 }
 
-function scanDirForNodesModules(dir,moduleName) {
-    var results = [];
-    var scopeName;
+function scanDirForNodesModules(dir,moduleName,package) {
+    let results = [];
+    let scopeName;
+    let files
     try {
-        var files = fs.readdirSync(dir);
-        if (moduleName) {
-            var m = /^(?:(@[^/]+)[/])?([^@/]+)/.exec(moduleName);
-            if (m) {
-                scopeName = m[1];
-                moduleName = m[2];
+        let isNodeRedModule = false
+        if(package) {
+            dir = path.join(package.moduleDir,'..')
+            files = [path.basename(package.moduleDir)]
+            moduleName =  (package.package ? package.package.name : null) || moduleName
+            isNodeRedModule = package.isNodeRedModule
+        } else {
+            files = fs.readdirSync(dir);
+            if (moduleName) {
+                var m = /^(?:(@[^/]+)[/])?([^@/]+)/.exec(moduleName);
+                if (m) {
+                    scopeName = m[1];
+                    moduleName = m[2];
+                }
             }
         }
-        for (var i=0;i<files.length;i++) {
-            var fn = files[i];
-            if (/^@/.test(fn)) {
+        for (let i=0;i<files.length;i++) {
+            let fn = files[i];
+            if (!isNodeRedModule && /^@/.test(fn)) {
                 if (scopeName && scopeName === fn) {
                     // Looking for a specific scope/module
                     results = results.concat(scanDirForNodesModules(path.join(dir,fn),moduleName));
@@ -149,16 +167,18 @@ function scanDirForNodesModules(dir,moduleName) {
                     results = results.concat(scanDirForNodesModules(path.join(dir,fn),moduleName));
                 }
             } else {
-                if (isIncluded(fn) && !isExcluded(fn) && (!moduleName || fn == moduleName)) {
-                    var pkgfn = path.join(dir,fn,"package.json");
+                if ((isNodeRedModule || (!moduleName || fn == moduleName)) && (isIncluded(fn) && !isExcluded(fn))) {
                     try {
-                        var pkg = require(pkgfn);
-                        if (pkg['node-red']) {
-                            if (!registryUtil.checkModuleAllowed(pkg.name,pkg.version,loadAllowList,loadDenyList)) {
-                                log.debug("! Module: "+pkg.name+" "+pkg.version+ " *ignored due to denyList*");
+                        const moduleDir = isNodeRedModule ? package.moduleDir : path.join(dir,fn);
+                        const pkg = package || getPackageDetails(moduleDir)
+                        if(pkg.error) {
+                            throw pkg.error
+                        }
+                        if (pkg.isNodeRedModule) {
+                            if (!pkg.allowed) {
+                                log.debug("! Module: "+pkg.package.name+" "+pkg.package.version+ " *ignored due to denyList*");
                             } else {
-                                var moduleDir = path.join(dir,fn);
-                                results.push({dir:moduleDir,package:pkg});
+                                results.push({dir:moduleDir,package:pkg.package});
                             }
                         }
                     } catch(err) {
@@ -182,11 +202,14 @@ function scanDirForNodesModules(dir,moduleName) {
  * @param moduleName the name of the module to be found
  * @return a list of node modules: {dir,package}
  */
-function scanTreeForNodesModules(moduleName) {
-    var dir = settings.coreNodesDir;
-    var results = [];
-    var userDir;
-
+ function scanTreeForNodesModules(moduleName) {
+    let coreNodesDir = settings.coreNodesDir;
+    let results = [];
+    let userDir;
+    let nodesDir;
+    if(settings.nodesDir) {
+        nodesDir = Array.isArray(settings.nodesDir) ? settings.nodesDir : [settings.nodesDir]
+    }
     if (settings.userDir) {
         packageList = getPackageList();
         userDir = path.join(settings.userDir,"node_modules");
@@ -201,15 +224,46 @@ function scanTreeForNodesModules(moduleName) {
         });
     }
 
-    if (dir) {
-        var up = path.resolve(path.join(dir,".."));
-        while (up !== dir) {
-            var pm = path.join(dir,"node_modules");
+    if (coreNodesDir) {
+        var up = path.resolve(path.join(coreNodesDir,".."));
+        while (up !== coreNodesDir) {
+            var pm = path.join(coreNodesDir,"node_modules");
             if (pm != userDir) {
                 results = results.concat(scanDirForNodesModules(pm,moduleName));
             }
-            dir = up;
-            up = path.resolve(path.join(dir,".."));
+            coreNodesDir = up;
+            up = path.resolve(path.join(coreNodesDir,".."));
+        }
+    }
+
+    // scan nodesDir for any node-red modules
+    /*
+    1. if !exist(package.json) || !package.json.has(node-red) => look for node_modules
+    2. exist(package.json) && package.json.has(node-red) => load this only
+    3. in original scan of nodesDir, ignore if:(exist(package.json) && package.json.has(node-red)) 
+    */
+    if (nodesDir) {
+        for (let dirIndex = 0; dirIndex < nodesDir.length; dirIndex++) {
+            const nodeDir = nodesDir[dirIndex];
+            const packageDetails = getPackageDetails(nodeDir)
+            if(packageDetails.isNodeRedModule) {
+                //we have found a node-red module, scan it
+                const nrModules = scanDirForNodesModules(nodeDir, packageDetails.package.name, packageDetails);
+                results = results.concat(nrModules);
+
+            } else if (packageDetails.has_node_modules) {
+                //If this dir has a `node_modues` dir, scan it
+                const nodeModulesDir = path.join(nodeDir, 'node_modules')
+                const nrModules = scanDirForNodesModules(nodeModulesDir, moduleName );
+                results = results.concat(nrModules);
+
+            } else {
+                //If this is not a node-red module AND it does NOT have a node_modules dir,
+                //it may be a directory of project directories or a node_modules dir?
+                //scan this instead
+                const nrModules = scanDirForNodesModules(nodeDir, moduleName);
+                results = results.concat(nrModules);
+            }
         }
     }
     return results;
@@ -274,24 +328,26 @@ function getModuleNodeFiles(module) {
 }
 
 function getNodeFiles(disableNodePathScan) {
-    var dir;
     // Find all of the nodes to load
-    var nodeFiles = [];
-    var results;
-
-    var dir;
-    var iconList = [];
+    let results;
+    let nodesDir;
+    if(settings.nodesDir) {
+        nodesDir = Array.isArray(settings.nodesDir) ? settings.nodesDir : [settings.nodesDir]
+    }
+    let dir;
+    let nodeFiles = [];
+    let iconList = [];
     if (settings.coreNodesDir) {
         results = getLocalNodeFiles(path.resolve(settings.coreNodesDir));
         nodeFiles = nodeFiles.concat(results.files);
         iconList = iconList.concat(results.icons);
-        var defaultLocalesPath = path.join(settings.coreNodesDir,"locales");
+        let defaultLocalesPath = path.join(settings.coreNodesDir,"locales");
         i18n.registerMessageCatalog("node-red",defaultLocalesPath,"messages.json");
     }
 
     if (settings.userDir) {
         dir = path.join(settings.userDir,"lib","icons");
-        var icons = scanIconDir(dir);
+        let icons = scanIconDir(dir);
         if (icons.length > 0) {
             iconList.push({path:dir,icons:icons});
         }
@@ -301,13 +357,9 @@ function getNodeFiles(disableNodePathScan) {
         nodeFiles = nodeFiles.concat(results.files);
         iconList = iconList.concat(results.icons);
     }
-    if (settings.nodesDir) {
-        dir = settings.nodesDir;
-        if (typeof settings.nodesDir == "string") {
-            dir = [dir];
-        }
-        for (var i=0;i<dir.length;i++) {
-            results = getLocalNodeFiles(dir[i]);
+    if (nodesDir) {
+        for (let i = 0; i < nodesDir.length; i++) {
+            results = getLocalNodeFiles(nodesDir[i], true);
             nodeFiles = nodeFiles.concat(results.files);
             iconList = iconList.concat(results.icons);
         }
@@ -479,7 +531,52 @@ function getPackageList() {
     }
     return list;
 }
-
+/**
+ * Gets the package json object for the supplied `dir`.  
+ * If there is no package.json or the `node-red` section is missing, `result.isNodeRedModule` will be `false`.
+ * If there is no package.json `isPackage` will be `false`.
+ * If an error occurs, `result.error` will contain the error.
+ * @param {string} dir The directory to inspect
+ */
+ function getPackageDetails(dir) {
+    const result = {
+        /** @type {string} The package directory */ 
+        moduleDir: dir,
+        /** @type {string} The full file path of package.json for this package */
+        packageFile: null,
+        /** @type {boolean} True if this is a valid node-red module */
+        isNodeRedModule: false,
+        /** @type {boolean} True if a package.json file is present */
+        isPackage: false,
+        /** @type {boolean} True if this a node-red module and passes the checks */
+        allowed: false,
+        /** @type {object} The contents of package.json */
+        package: null,
+    }
+    if (!dir) {  return result }
+    try {
+        const packagefile = path.join(dir,'package.json')
+        result.has_node_modules = fs.existsSync(path.join(dir,'node_modules'))
+        if(!fs.existsSync(packagefile)) {
+            return result
+        }
+        result.packageFile = packagefile
+        const pkg = require(packagefile)
+        result.package = pkg
+        if(result.package) {
+            result.allowed = true
+            result.isPackage = true
+            result.isNodeRedModule = typeof result.package['node-red'] === 'object'
+            if(result.isNodeRedModule) {
+                result.isNodeRedModule = true;
+                result.allowed = registryUtil.checkModuleAllowed(pkg.name,pkg.version,loadAllowList,loadDenyList) 
+            }
+        }
+    } catch(err) {
+        result.error = err; // this is not a package we are interested in!
+    }
+    return result || result;
+}
 module.exports = {
     init: init,
     getNodeFiles: getNodeFiles,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@node-red/registry",
-    "version": "3.0.0-beta.2",
+    "version": "3.0.0",
     "license": "Apache-2.0",
     "main": "./lib/index.js",
     "repository": {
@@ -16,11 +16,11 @@
         }
     ],
     "dependencies": {
-        "@node-red/util": "3.0.0-beta.2",
+        "@node-red/util": "3.0.0",
         "clone": "2.1.2",
         "fs-extra": "10.1.0",
         "semver": "7.3.7",
         "tar": "6.1.11",
-        "uglify-js": "3.15.5"
+        "uglify-js": "3.16.2"
     }
 }