Merge branch 'feat-7' into alpha

Author: dominykas

.labrc.js

@@ -0,0 +1,5 @@
+'use strict';
+
+exports.globals = [
+    'Symbol(__RESOLVED_TEMP_DIRECTORY__)'
+].join(',');

README.md

@@ -5,45 +5,59 @@ List the Node.js versions supported by the package/repository
 ## Usage (command line)
 
 ```
-$ npx detect-node-support [path]
+$ npx detect-node-support [options] <path>
 ```
 
 Prints the supported Node.js versions for the package at the specified path. When the path is not a git repository - tries to read the git repository from `package.json` and tries to detect the versions listed in the repository as well.
 
 When `path` is omitted, tries to detect the versions for `cwd`. 
 
 ```
-$ npx detect-node-support [package name]
+$ npx detect-node-support [options] <package name>
 ```
 
 Prints supported Node.js versions for the package from the registry.
 
 ```
-$ npx detect-node-support [repository git URL]
+$ npx detect-node-support [options] <repository git URL>
 ```
 
 Prints supported Node.js versions for the package at the git URL.
 
+### Options
+
+* `--deps` - include the support information of all dependencies
+
 ## Usage (library)
 
 ```
-const result = await require('detect-node-support').detect({ path });
+const result = await require('detect-node-support').detect({ path }, options);
 ```
 
 `path` should be a folder in the local file system. When the path is not a git repository - tries to read the git repository from `package.json` and tries to detect the versions listed in the repository as well. 
 
 ```
-const result = await require('detect-node-support').detect({ packageName });
+const result = await require('detect-node-support').detect({ packageName }, options);
 ```
 
 `packageName` is a string name for the package in the registry. 
 
 ```
-const result = await require('detect-node-support').detect({ repository });
+const result = await require('detect-node-support').detect({ repository }, options);
 ```
 
 `repository` is a URL for a git repository.
 
+```
+const result = await require('detect-node-support').detect(what, options);
+```
+
+`what` is a string containing either a package name, or a local path, or a reference to a git repository.
+
+### Options
+
+- `deps: false` - when `true`, include the support information of all dependencies.
+
 ### Result
 
 - Throws if the `path` / `repository` does not have a `package.json`
@@ -88,6 +102,30 @@ const result = {
             "lts/*": "12.14.0",
             "invalid-specifier": false
         }       
+    },
+
+    // only present when explicitly requested
+    "dependencies": {
+
+        // will contain a support object for every unique dependency in the tree
+        // note that the `version` will be the _latest_ version available in the registry
+        // see below for the actual versions installed   
+        "support": [
+            { 
+                "name": "dependency-A" 
+                /*... other fields ...*/ 
+            },
+            { 
+                "name": "dependency-B" 
+                /*... other fields ...*/ 
+            }           
+        ],
+    
+        // will contain a list of unique versions for each dependency found in the dependency tree
+        "versions": {
+            "dependency-A": ["0.0.10", "1.2.5"],
+            "dependency-B": ["0.5.3", "1.0.0"]
+        }       
     }
 }
 ```

bin/detect-node-support

@@ -2,58 +2,45 @@
 
 'use strict';
 
-const Fs = require('fs');
-const NodeSupport = require('..');
-const { URL } = require('url');
+const Minimist = require('minimist');
+const Util = require('util');
 
+const NodeSupport = require('..');
 
 const internals = {};
 
 internals.help = () => {
 
-    return `Usage: detect-node-support [ path | Github URL | npm package name ]`;
-};
-
+    return `
+Usage: detect-node-support [--deps] [--json] <what>
 
-internals.autoDetect = (what) => {
+  <what> can be an npm package name, or a Github URL, or a path 
+  with a package.json.
 
-    try {
-        var url = new URL(what);
-    }
-    catch (err) {
-        if (err.code !== 'ERR_INVALID_URL') {
-            throw err;
-        }
-    }
-
-    if (url) {
-        return NodeSupport.detect({ repository: url.href });
-    }
-
-    if (Fs.existsSync(what)) {
-        return NodeSupport.detect({ path: what });
-    }
-
-    if (what.includes('/') && !what.startsWith('@')) {
-        return  NodeSupport.detect({ repository: `https://github.com/${what}` });
-    }
-
-    return NodeSupport.detect({ packageName: what });
+Options:
+  --deps    Include the support information of all dependencies
+  --json    Print JSON formatted output
+`;
 };
 
-exports.main = async (nodeBin, thisBin, what) => {
+exports.main = async ({ _: [what], deps, json }) => {
 
     if (!what) {
         console.log(internals.help());
         return;
     }
 
-    const result = await internals.autoDetect(what);
+    const result = await NodeSupport.detect(what, { deps });
 
-    console.log(result);
+    if (json) {
+        console.log(JSON.stringify(result, null, '  '));
+    }
+    else {
+        console.log(Util.inspect(result, false, null, true));
+    }
 };
 
-exports.main(...process.argv)
+exports.main(Minimist(process.argv.slice(2), { boolean: ['deps', 'json'] }))
     .catch((err) => {
 
         console.error(err);

lib/deps.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const { Arborist } = require('@npmcli/arborist');
+const Fs = require('fs');
+const Path = require('path');
+const Tempy = require('tempy');
+
+const Package = require('./package');
+
+const internals = {};
+
+
+internals.walk = (node, callback) => {
+
+    callback(node);
+
+    node.children.forEach((child) => {
+
+        internals.walk(child, callback);
+    });
+};
+
+
+exports.resolve = async ({ packageJson, lockfile }) => {
+
+    const path = Tempy.directory();
+    Fs.writeFileSync(Path.join(path, 'package.json'), JSON.stringify(packageJson, null, '  '));
+
+    if (lockfile) {
+        Fs.writeFileSync(Path.join(path, 'package-lock.json'), JSON.stringify(lockfile, null, '  '));
+    }
+
+    const arborist = new Arborist({ path });
+
+    await arborist.buildIdealTree();
+
+    const map = {};
+
+    internals.walk(arborist.idealTree, (node) => {
+
+        if (node === arborist.idealTree) {
+            return;
+        }
+
+        if (node.dev) {
+            return;
+        }
+
+        map[node.name] = map[node.name] || new Set();
+        map[node.name].add(node.package.version);
+    });
+
+    const result = {};
+
+    for (const name of Object.keys(map).sort()) {
+        result[name] = [...map[name]];
+    }
+
+    return result;
+};
+
+internals.tryLoad = async (loadFile, filename) => {
+
+    try {
+        return await loadFile(filename, { json: true });
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT') {
+            throw err;
+        }
+    }
+};
+
+exports.detect = async ({ packageJson, loadFile }) => {
+
+    const lockfile = (await internals.tryLoad(loadFile, 'package-lock.json')) || (await internals.tryLoad(loadFile, 'npm-shrinkwrap.json'));
+
+    const versions = await exports.resolve({ packageJson, lockfile });
+
+    const support = [];
+
+    for (const packageName of Object.keys(versions)) {
+        try {
+            const { result } = await Package.detect({ packageName });
+            support.push(result);
+        }
+        catch (err) {
+            console.warn(`Failed to detect support for ${packageName}: ${err && err.message}`);
+        }
+    }
+
+    return { support, versions };
+};

lib/engines.js

@@ -1,11 +1,11 @@
 'use strict';
 
-exports.detect = ({ engines }) => {
+exports.detect = ({ packageJson }) => {
 
-    if (engines) {
+    if (packageJson.engines) {
 
         return {
-            engines: engines.node
+            engines: packageJson.engines.node
         };
     }
 };

lib/index.js

@@ -1,24 +1,15 @@
 'use strict';
 
-const Engines = require('./engines');
+const Deps = require('./deps');
 const Package = require('./package');
-const Travis = require('./travis');
 
-exports.detect = async ({ path, repository, packageName }) => {
+exports.detect = async function (what, { deps } = {}) {
 
-    const packageInfo = await Package.detect({ path, repository, packageName });
+    const { result, meta } = await Package.detect(what);
 
-    const result = {};
-
-    result.name = packageInfo.name;
-    result.version = packageInfo.version;
-    result.commit = await packageInfo.getCommit();
-    result.timestamp = Date.now();
-
-    const travis = await Travis.detect(packageInfo);
-    const engines = await Engines.detect(packageInfo);
-
-    Object.assign(result, travis, engines);
+    if (deps) {
+        result.dependencies = await Deps.detect(meta);
+    }
 
     return result;
 };

lib/loader.js

@@ -45,7 +45,7 @@ internals.createPackageLoader = async (packageName) => {
                 const result = await repositoryLoader.loadFile(filename, options);
 
                 if (filename === 'package.json' && result.name !== packageName) {
-                    throw new Error(`${repository} does not contain ${packageName}`);
+                    throw new Error(`${repository} does not contain ${packageName}. Monorepo not supported: https://github.com/pkgjs/detect-node-support/issues/6`);
                 }
 
                 return result;