nx 16.6.0-beta.7 → 16.6.0-beta.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "16.6.0-beta.7",
+  "version": "16.6.0-beta.8",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -32,7 +32,7 @@
   },
   "homepage": "https://nx.dev",
   "dependencies": {
-    "@nrwl/tao": "16.6.0-beta.7",
+    "@nrwl/tao": "16.6.0-beta.8",
     "@parcel/watcher": "2.0.4",
     "@yarnpkg/lockfile": "^1.1.0",
     "@yarnpkg/parsers": "3.0.0-rc.46",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "16.6.0-beta.7",
-    "@nx/nx-darwin-x64": "16.6.0-beta.7",
-    "@nx/nx-freebsd-x64": "16.6.0-beta.7",
-    "@nx/nx-linux-arm-gnueabihf": "16.6.0-beta.7",
-    "@nx/nx-linux-arm64-gnu": "16.6.0-beta.7",
-    "@nx/nx-linux-arm64-musl": "16.6.0-beta.7",
-    "@nx/nx-linux-x64-gnu": "16.6.0-beta.7",
-    "@nx/nx-linux-x64-musl": "16.6.0-beta.7",
-    "@nx/nx-win32-arm64-msvc": "16.6.0-beta.7",
-    "@nx/nx-win32-x64-msvc": "16.6.0-beta.7"
+    "@nx/nx-darwin-arm64": "16.6.0-beta.8",
+    "@nx/nx-darwin-x64": "16.6.0-beta.8",
+    "@nx/nx-freebsd-x64": "16.6.0-beta.8",
+    "@nx/nx-linux-arm-gnueabihf": "16.6.0-beta.8",
+    "@nx/nx-linux-arm64-gnu": "16.6.0-beta.8",
+    "@nx/nx-linux-arm64-musl": "16.6.0-beta.8",
+    "@nx/nx-linux-x64-gnu": "16.6.0-beta.8",
+    "@nx/nx-linux-x64-musl": "16.6.0-beta.8",
+    "@nx/nx-win32-arm64-msvc": "16.6.0-beta.8",
+    "@nx/nx-win32-x64-msvc": "16.6.0-beta.8"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -177,5 +177,5 @@
   },
   "main": "./bin/nx.js",
   "types": "./bin/nx.d.ts",
-  "gitHead": "6afe0a7c20059d6cdc8e455758a17886f933a0dc"
+  "gitHead": "d1d06349e703d903ac47fb7adc7d250ce140d77e"
 }

package/src/hasher/task-hasher.js

@@ -13,6 +13,7 @@ const set_hash_env_1 = require("./set-hash-env");
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
 const path_2 = require("../utils/path");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
 class DaemonBasedTaskHasher {
     constructor(daemonClient, taskGraph, runnerOptions) {
         this.daemonClient = daemonClient;
@@ -246,59 +247,35 @@ class TaskHasherImpl {
         this.externalDependencyHashes.set(externalNodeName, [combinedHash]);
         return combinedHash;
     }
-    hashExternalDependency(externalNodeName, visited) {
-        // try to retrieve the hash from cache
-        if (this.externalDependencyHashes.has(externalNodeName)) {
-            return this.externalDependencyHashes.get(externalNodeName);
-        }
-        visited.add(externalNodeName);
+    hashSingleExternalDependency(externalNodeName) {
         const node = this.projectGraph.externalNodes[externalNodeName];
-        const partialHashes = new Set();
-        if (node) {
-            if (node.data.hash) {
-                // we already know the hash of this dependency
-                partialHashes.add({
-                    value: node.data.hash,
-                    details: {
-                        [externalNodeName]: node.data.hash,
-                    },
-                });
-            }
-            else {
-                // we take version as a hash
-                partialHashes.add({
-                    value: node.data.version,
-                    details: {
-                        [externalNodeName]: node.data.version,
-                    },
-                });
-            }
-            // we want to calculate the hash of the entire dependency tree
-            if (this.projectGraph.dependencies[externalNodeName]) {
-                this.projectGraph.dependencies[externalNodeName].forEach((d) => {
-                    if (!visited.has(d.target)) {
-                        for (const hash of this.hashExternalDependency(d.target, visited)) {
-                            partialHashes.add(hash);
-                        }
-                    }
-                });
-            }
+        if (node.data.hash) {
+            // we already know the hash of this dependency
+            return {
+                value: node.data.hash,
+                details: {
+                    [externalNodeName]: node.data.hash,
+                },
+            };
         }
         else {
-            // unknown dependency
-            // this may occur if dependency is not an npm package
-            // but rather symlinked in node_modules or it's pointing to a remote git repo
-            // in this case we have no information about the versioning of the given package
-            partialHashes.add({
-                value: `__${externalNodeName}__`,
+            // we take version as a hash
+            return {
+                value: node.data.version,
                 details: {
-                    [externalNodeName]: `__${externalNodeName}__`,
+                    [externalNodeName]: node.data.version,
                 },
-            });
+            };
         }
-        const partialHashArray = Array.from(partialHashes);
-        this.externalDependencyHashes.set(externalNodeName, partialHashArray);
-        return partialHashArray;
+    }
+    hashExternalDependency(externalNodeName) {
+        const partialHashes = new Set();
+        partialHashes.add(this.hashSingleExternalDependency(externalNodeName));
+        const deps = (0, project_graph_utils_1.findAllProjectNodeDependencies)(externalNodeName, this.projectGraph, true);
+        for (const dep of deps) {
+            partialHashes.add(this.hashSingleExternalDependency(dep));
+        }
+        return Array.from(partialHashes);
     }
     hashTarget(projectName, targetName, selfInputs) {
         const projectNode = this.projectGraph.nodes[projectName];
@@ -313,6 +290,11 @@ class TaskHasherImpl {
             target.executor.startsWith(`@nx/`)) {
             const executorPackage = target.executor.split(':')[0];
             const executorNodeName = this.findExternalDependencyNodeName(executorPackage);
+            // This is either a local plugin or a non-existent executor
+            if (!executorNodeName) {
+                // TODO: This should not return null if it is a local plugin's executor
+                return null;
+            }
             return this.getExternalDependencyHash(executorNodeName);
         }
         else {
@@ -326,6 +308,9 @@ class TaskHasherImpl {
                     const externalDependencies = input['externalDependencies'];
                     for (let dep of externalDependencies) {
                         dep = this.findExternalDependencyNodeName(dep);
+                        if (!dep) {
+                            throw new Error(`The externalDependency "${dep}" for "${projectName}:${targetName}" could not be found`);
+                        }
                         partialHashes.push(this.getExternalDependencyHash(dep));
                     }
                 }
@@ -363,8 +348,8 @@ class TaskHasherImpl {
                 return node.name;
             }
         }
-        // not found, just return the package name
-        return packageName;
+        // not found
+        return null;
     }
     hashSingleProjectInputs(projectName, inputs) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -537,7 +522,7 @@ class TaskHasherImpl {
     calculateExternalDependencyHashes() {
         const keys = Object.keys(this.projectGraph.externalNodes);
         for (const externalNodeName of keys) {
-            this.hashExternalDependency(externalNodeName, new Set());
+            this.externalDependencyHashes.set(externalNodeName, this.hashExternalDependency(externalNodeName));
         }
     }
 }

package/src/utils/project-graph-utils.d.ts

@@ -6,9 +6,10 @@ export declare function mergeNpmScriptsWithTargets(projectRoot: string, targets:
 export declare function getSourceDirOfDependentProjects(projectName: string, projectGraph?: ProjectGraph): [projectDirs: string[], warnings: string[]];
 /**
  * Find all internal project dependencies.
- * All the external (npm) dependencies will be filtered out
+ * All the external (npm) dependencies will be filtered out unless includeExternalDependencies is set to true
  * @param {string} parentNodeName
  * @param {ProjectGraph} projectGraph
+ * @param includeExternalDependencies
  * @returns {string[]}
  */
-export declare function findAllProjectNodeDependencies(parentNodeName: string, projectGraph?: ProjectGraph): string[];
+export declare function findAllProjectNodeDependencies(parentNodeName: string, projectGraph?: ProjectGraph, includeExternalDependencies?: boolean): string[];

package/src/utils/project-graph-utils.js

@@ -52,19 +52,20 @@ function getSourceDirOfDependentProjects(projectName, projectGraph = (0, project
 exports.getSourceDirOfDependentProjects = getSourceDirOfDependentProjects;
 /**
  * Find all internal project dependencies.
- * All the external (npm) dependencies will be filtered out
+ * All the external (npm) dependencies will be filtered out unless includeExternalDependencies is set to true
  * @param {string} parentNodeName
  * @param {ProjectGraph} projectGraph
+ * @param includeExternalDependencies
  * @returns {string[]}
  */
-function findAllProjectNodeDependencies(parentNodeName, projectGraph = (0, project_graph_1.readCachedProjectGraph)()) {
+function findAllProjectNodeDependencies(parentNodeName, projectGraph = (0, project_graph_1.readCachedProjectGraph)(), includeExternalDependencies = false) {
     const dependencyNodeNames = new Set();
-    collectDependentProjectNodesNames(projectGraph, dependencyNodeNames, parentNodeName);
+    collectDependentProjectNodesNames(projectGraph, dependencyNodeNames, parentNodeName, includeExternalDependencies);
     return Array.from(dependencyNodeNames);
 }
 exports.findAllProjectNodeDependencies = findAllProjectNodeDependencies;
 // Recursively get all the dependencies of the node
-function collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, parentNodeName) {
+function collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, parentNodeName, includeExternalDependencies) {
     var _a;
     const dependencies = nxDeps.dependencies[parentNodeName];
     if (!dependencies) {
@@ -74,16 +75,21 @@ function collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, parentNo
     }
     for (const dependency of dependencies) {
         const dependencyName = dependency.target;
-        // we're only interested in internal nodes, not external
-        if ((_a = nxDeps.externalNodes) === null || _a === void 0 ? void 0 : _a[dependencyName]) {
-            continue;
-        }
         // skip dependencies already added (avoid circular dependencies)
         if (dependencyNodeNames.has(dependencyName)) {
             continue;
         }
+        // we're only interested in internal nodes, not external
+        if ((_a = nxDeps.externalNodes) === null || _a === void 0 ? void 0 : _a[dependencyName]) {
+            if (includeExternalDependencies) {
+                dependencyNodeNames.add(dependencyName);
+            }
+            else {
+                continue;
+            }
+        }
         dependencyNodeNames.add(dependencyName);
         // Get the dependencies of the dependencies
-        collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, dependencyName);
+        collectDependentProjectNodesNames(nxDeps, dependencyNodeNames, dependencyName, includeExternalDependencies);
     }
 }