nx 19.8.2 → 19.8.4

package/src/executors/run-commands/run-commands.impl.js

@@ -16,22 +16,11 @@ let pseudoTerminal;
 const childProcesses = new Set();
 function loadEnvVarsFile(path, env = {}) {
     (0, task_env_1.unloadDotEnvFile)(path, env);
-    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env, true);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
     if (result.error) {
         throw result.error;
     }
 }
-function loadEnvVars(path, env = {}) {
-    if (path) {
-        loadEnvVarsFile(path, env);
-    }
-    else {
-        try {
-            loadEnvVarsFile('.env', env);
-        }
-        catch { }
-    }
-}
 const propKeys = [
     'command',
     'commands',
@@ -292,20 +281,24 @@ function calculateCwd(cwd, context) {
         return cwd;
     return path.join(context.root, cwd);
 }
-function processEnv(color, cwd, env, envFile) {
-    const localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
-    let res = {
+/**
+ * Env variables are processed in the following order:
+ * - env option from executor options
+ * - env file from envFile option if provided
+ * - local env variables
+ */
+function processEnv(color, cwd, envOptionFromExecutor, envFile) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+    localEnv = {
         ...process.env,
         ...localEnv,
     };
-    // env file from envFile option takes priority over process env
-    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false') {
-        loadEnvVars(envFile, res);
+    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+        loadEnvVarsFile(envFile, localEnv);
     }
-    // env variables from env option takes priority over everything else
-    res = {
-        ...res,
-        ...env,
+    let res = {
+        ...localEnv,
+        ...envOptionFromExecutor,
     };
     // need to override PATH to make sure we are using the local node_modules
     if (localEnv.PATH)

package/src/hasher/hash-task.d.ts

@@ -2,5 +2,7 @@ import { Task, TaskGraph } from '../config/task-graph';
 import { TaskHasher } from './task-hasher';
 import { ProjectGraph } from '../config/project-graph';
 import { NxJsonConfiguration } from '../config/nx-json';
-export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration): Promise<void>;
-export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv): Promise<void>;
+import { TaskDetails } from '../native';
+export declare function getTaskDetails(): TaskDetails | null;
+export declare function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, tasksDetails: TaskDetails | null): Promise<void>;
+export declare function hashTask(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, task: Task, env: NodeJS.ProcessEnv, taskDetails: TaskDetails | null): Promise<void>;

package/src/hasher/hash-task.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskDetails = getTaskDetails;
 exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
 exports.hashTask = hashTask;
 const utils_1 = require("../tasks-runner/utils");
@@ -19,9 +20,8 @@ function getTaskDetails() {
     }
     return taskDetails;
 }
-async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson) {
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
     performance.mark('hashMultipleTasks:start');
-    const taskDetails = getTaskDetails();
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
         const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
@@ -42,9 +42,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         tasksToHash[i].hash = hashes[i].value;
         tasksToHash[i].hashDetails = hashes[i].details;
     }
-    // TODO: Remove if when sqlite is always on
-    if (taskDetails) {
-        taskDetails.recordTaskDetails(tasksToHash.map((task) => ({
+    if (tasksDetails?.recordTaskDetails) {
+        tasksDetails.recordTaskDetails(tasksToHash.map((task) => ({
             hash: task.hash,
             project: task.target.project,
             target: task.target.target,
@@ -54,9 +53,8 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
     performance.mark('hashMultipleTasks:end');
     performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
 }
-async function hashTask(hasher, projectGraph, taskGraph, task, env) {
+async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
     performance.mark('hashSingleTask:start');
-    const taskDetails = getTaskDetails();
     const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const { value, details } = await (customHasher
@@ -72,8 +70,7 @@ async function hashTask(hasher, projectGraph, taskGraph, task, env) {
         : hasher.hashTask(task, taskGraph, env));
     task.hash = value;
     task.hashDetails = details;
-    // TODO: Remove if when wasm supports sqlite
-    if (taskDetails) {
+    if (taskDetails?.recordTaskDetails) {
         taskDetails.recordTaskDetails([
             {
                 hash: task.hash,

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -42,6 +42,18 @@ function getNxInitDate() {
         return null;
     }
 }
+async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxInitDate) {
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    const response = await require('axios').post(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
+        workspaceName,
+        installationSource,
+        nxInitDate,
+    });
+    if (response.data.message) {
+        throw new Error(response.data.message);
+    }
+    return response.data;
+}
 async function createNxCloudWorkspaceV2(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
     const response = await require('axios').post(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
@@ -69,6 +81,19 @@ async function printSuccessMessage(token, installationSource, usesGithub) {
     });
     return connectCloudUrl;
 }
+function addNxCloudAccessTokenToNxJson(tree, token, directory = '') {
+    const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
+    if (tree.exists(nxJsonPath)) {
+        (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {
+            const overrideUrl = process.env.NX_CLOUD_API || process.env.NRWL_API;
+            if (overrideUrl) {
+                nxJson.nxCloudUrl = overrideUrl;
+            }
+            nxJson.nxCloudAccessToken = token;
+            return nxJson;
+        });
+    }
+}
 function addNxCloudIdToNxJson(tree, nxCloudId, directory = '') {
     const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
     if (tree.exists(nxJsonPath)) {
@@ -89,6 +114,7 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
         return null;
     }
     const isGitHubDetected = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
+    let responseFromCreateNxCloudWorkspaceV1;
     let responseFromCreateNxCloudWorkspaceV2;
     /**
      * Do not create an Nx Cloud token if the user is using GitHub and
@@ -98,12 +124,34 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
         isGitHubDetected &&
         schema.installationSource === 'nx-connect')
         return null;
-    responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
-    addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
-        silent: schema.hideFormatLogs,
-    });
-    return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
+    try {
+        responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+    }
+    catch (e) {
+        if (e.response?.status === 404) {
+            responseFromCreateNxCloudWorkspaceV1 = await createNxCloudWorkspaceV1(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+        }
+        else {
+            throw e;
+        }
+    }
+    if (responseFromCreateNxCloudWorkspaceV2) {
+        addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
+        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+            silent: schema.hideFormatLogs,
+        });
+        return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
+    }
+    else if (responseFromCreateNxCloudWorkspaceV1) {
+        addNxCloudAccessTokenToNxJson(tree, responseFromCreateNxCloudWorkspaceV1?.token, schema.directory);
+        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+            silent: schema.hideFormatLogs,
+        });
+        return responseFromCreateNxCloudWorkspaceV1.token;
+    }
+    else {
+        throw new Error('Could not create an Nx Cloud Workspace. Please try again.');
+    }
 }
 async function connectToNxCloudGenerator(tree, options) {
     await connectToNxCloud(tree, options);

package/src/nx-cloud/utilities/axios.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createApiAxiosInstance = createApiAxiosInstance;
 const path_1 = require("path");
 const environment_1 = require("./environment");
-const axios = require('axios');
 function createApiAxiosInstance(options) {
     let axiosConfigBuilder = (axiosConfig) => axiosConfig;
     const baseUrl = process.env.NX_CLOUD_API || options.url || 'https://cloud.nx.app';
@@ -17,7 +16,7 @@ function createApiAxiosInstance(options) {
         const { nxCloudProxyConfig } = require((0, path_1.join)(process.cwd(), options.customProxyConfigPath));
         axiosConfigBuilder = nxCloudProxyConfig ?? axiosConfigBuilder;
     }
-    return axios.create(axiosConfigBuilder({
+    return require('axios').create(axiosConfigBuilder({
         baseURL: baseUrl,
         timeout: environment_1.NX_CLOUD_NO_TIMEOUTS ? environment_1.UNLIMITED_TIMEOUT : 10000,
         headers: { authorization: accessToken },

package/src/nx-cloud/utilities/onboarding.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNxCloudOnboardingURLForWelcomeApp = createNxCloudOnboardingURLForWelcomeApp;
 exports.getNxCloudAppOnBoardingUrl = getNxCloudAppOnBoardingUrl;
 exports.readNxCloudToken = readNxCloudToken;
-const devkit_exports_1 = require("../../devkit-exports");
 const is_workspace_claimed_1 = require("./is-workspace-claimed");
 const url_shorten_1 = require("./url-shorten");
 const run_command_1 = require("../../tasks-runner/run-command");
+const nx_json_1 = require("../../generators/utils/nx-json");
 async function createNxCloudOnboardingURLForWelcomeApp(tree, token) {
     token = token || readNxCloudToken(tree);
     if (!token) {
@@ -22,7 +22,7 @@ async function getNxCloudAppOnBoardingUrl(token) {
     return onboardingUrl;
 }
 function readNxCloudToken(tree) {
-    const nxJson = (0, devkit_exports_1.readNxJson)(tree);
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
     const { accessToken, nxCloudId } = (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
     return accessToken || nxCloudId;
 }

package/src/nx-cloud/utilities/url-shorten.js

@@ -7,7 +7,7 @@ exports.getNxCloudVersion = getNxCloudVersion;
 exports.removeVersionModifier = removeVersionModifier;
 exports.versionIsValid = versionIsValid;
 exports.compareCleanCloudVersions = compareCleanCloudVersions;
-const devkit_exports_1 = require("../../devkit-exports");
+const logger_1 = require("../../utils/logger");
 const git_utils_1 = require("../../utils/git-utils");
 const get_cloud_options_1 = require("./get-cloud-options");
 /**
@@ -27,7 +27,7 @@ async function createNxCloudOnboardingURL(onboardingSource, accessToken, usesGit
         }
     }
     catch (e) {
-        devkit_exports_1.logger.verbose(`Failed to get Nx Cloud version.
+        logger_1.logger.verbose(`Failed to get Nx Cloud version.
     ${e}`);
         return apiUrl;
     }
@@ -46,7 +46,7 @@ async function createNxCloudOnboardingURL(onboardingSource, accessToken, usesGit
         return `${apiUrl}/connect/${response.data}`;
     }
     catch (e) {
-        devkit_exports_1.logger.verbose(`Failed to shorten Nx Cloud URL.
+        logger_1.logger.verbose(`Failed to shorten Nx Cloud URL.
     ${e}`);
         return getURLifShortenFailed(usesGithub, githubSlug === 'github' ? null : githubSlug, apiUrl, source, accessToken);
     }
@@ -96,7 +96,7 @@ async function getInstallationSupportsGitHub(apiUrl) {
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            devkit_exports_1.logger.warn(`Failed to access system features. GitHub integration assumed to be disabled. 
+            logger_1.logger.warn(`Failed to access system features. GitHub integration assumed to be disabled. 
     ${e}`);
         }
         return false;
@@ -116,7 +116,7 @@ async function getNxCloudVersion(apiUrl) {
         return version;
     }
     catch (e) {
-        devkit_exports_1.logger.verbose(`Failed to get version of Nx Cloud.
+        logger_1.logger.verbose(`Failed to get version of Nx Cloud.
       ${e}`);
         return null;
     }

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

@@ -184,7 +184,7 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
                     }
                 }
                 else {
-                    result[metadataKey] = value;
+                    result[metadataKey][key] = value[key];
                     if (sourceMap) {
                         sourceMap[`${baseSourceMapPath}.${metadataKey}`] =
                             sourceInformation;

package/src/tasks-runner/cache.d.ts

@@ -11,7 +11,8 @@ export type TaskWithCachedResult = {
     task: Task;
     cachedResult: CachedResult;
 };
-export declare function getCache(nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions): DbCache | Cache;
+export declare function dbCacheEnabled(nxJson?: NxJsonConfiguration): boolean;
+export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
 export declare class DbCache {
     private readonly options;
     private cache;

package/src/tasks-runner/cache.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
+exports.dbCacheEnabled = dbCacheEnabled;
 exports.getCache = getCache;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
@@ -19,14 +20,17 @@ const update_manager_1 = require("../nx-cloud/update-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const is_ci_1 = require("../utils/is-ci");
 const output_1 = require("../utils/output");
-function getCache(nxJson, options) {
-    return process.env.NX_DISABLE_DB !== 'true' &&
-        (nxJson.enableDbCache === true || process.env.NX_DB_CACHE === 'true')
+function dbCacheEnabled(nxJson = (0, nx_json_1.readNxJson)()) {
+    return (process.env.NX_DISABLE_DB !== 'true' &&
+        (nxJson.enableDbCache === true || process.env.NX_DB_CACHE === 'true'));
+}
+// Do not change the order of these arguments as this function is used by nx cloud
+function getCache(options) {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    return dbCacheEnabled(nxJson)
         ? new DbCache({
             // Remove this in Nx 21
-            nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
-                ? options.remoteCache
-                : null,
+            nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson) ? options.remoteCache : null,
         })
         : new Cache(options);
 }

package/src/tasks-runner/create-task-graph.d.ts

@@ -18,9 +18,11 @@ export declare class ProcessTasks {
     private processTasksForMultipleProjects;
     private processTasksForSingleProject;
     private processTasksForDependencies;
+    private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
     getId(project: string, target: string, configuration: string | undefined): string;
+    private filterDummyTasks;
 }
 export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
 export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;

package/src/tasks-runner/create-task-graph.js

@@ -6,6 +6,7 @@ exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const output_1 = require("../utils/output");
+const DUMMY_TASK_TARGET = '__nx_dummy_task__';
 class ProcessTasks {
     constructor(extraTargetDependencies, projectGraph) {
         this.extraTargetDependencies = extraTargetDependencies;
@@ -52,10 +53,11 @@ class ProcessTasks {
                 this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
             }
         }
-        for (const projectName of Object.keys(this.dependencies)) {
-            if (this.dependencies[projectName].length > 1) {
-                this.dependencies[projectName] = [
-                    ...new Set(this.dependencies[projectName]).values(),
+        this.filterDummyTasks();
+        for (const taskId of Object.keys(this.dependencies)) {
+            if (this.dependencies[taskId].length > 0) {
+                this.dependencies[taskId] = [
+                    ...new Set(this.dependencies[taskId].filter((d) => d !== taskId)).values(),
                 ];
             }
         }
@@ -113,6 +115,9 @@ class ProcessTasks {
         }
     }
     processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides) {
+        if (!this.projectGraph.dependencies.hasOwnProperty(projectUsedToDeriveDependencies)) {
+            return;
+        }
         for (const dep of this.projectGraph.dependencies[projectUsedToDeriveDependencies]) {
             const depProject = this.projectGraph.nodes[dep.target];
             // this is to handle external dependencies
@@ -132,10 +137,20 @@ class ProcessTasks {
                 }
             }
             else {
-                this.processTask(task, depProject.name, configuration, overrides);
+                const dummyId = this.getId(depProject.name, DUMMY_TASK_TARGET, undefined);
+                this.dependencies[task.id].push(dummyId);
+                this.dependencies[dummyId] = [];
+                const noopTask = this.createDummyTask(dummyId, task);
+                this.processTask(noopTask, depProject.name, configuration, overrides);
             }
         }
     }
+    createDummyTask(id, task) {
+        return {
+            ...task,
+            id,
+        };
+    }
     createTask(id, project, target, resolvedConfiguration, overrides) {
         if (!project.data.targets[target]) {
             throw new Error(`Cannot find configuration for task ${project.name}:${target}`);
@@ -173,6 +188,25 @@ class ProcessTasks {
         }
         return id;
     }
+    filterDummyTasks() {
+        for (const [key, deps] of Object.entries(this.dependencies)) {
+            const normalizedDeps = [];
+            for (const dep of deps) {
+                if (dep.endsWith(DUMMY_TASK_TARGET)) {
+                    normalizedDeps.push(...this.dependencies[dep].filter((d) => !d.endsWith(DUMMY_TASK_TARGET)));
+                }
+                else {
+                    normalizedDeps.push(dep);
+                }
+            }
+            this.dependencies[key] = normalizedDeps;
+        }
+        for (const key of Object.keys(this.dependencies)) {
+            if (key.endsWith(DUMMY_TASK_TARGET)) {
+                delete this.dependencies[key];
+            }
+        }
+    }
 }
 exports.ProcessTasks = ProcessTasks;
 function createTaskGraph(projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {

package/src/tasks-runner/life-cycles/dynamic-run-many-terminal-output-life-cycle.js

@@ -224,6 +224,11 @@ async function createRunManyDynamicOutputRenderer({ projectNames, tasks, args, o
         clearRenderInterval();
         const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
         moveCursorToStartOfPinnedFooter();
+        if (totalTasks === 0) {
+            renderPinnedFooter([output_1.output.applyNxPrefix('gray', 'No tasks were run')]);
+            resolveRenderIsDonePromise();
+            return;
+        }
         if (totalSuccessfulTasks === totalTasks) {
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -23,6 +23,9 @@ class StaticRunManyTerminalOutputLifeCycle {
         this.allCompletedTasks = new Map();
     }
     startCommand() {
+        if (this.tasks.length === 0) {
+            return;
+        }
         if (this.projectNames.length <= 0) {
             output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
             return;
@@ -45,6 +48,10 @@ class StaticRunManyTerminalOutputLifeCycle {
     }
     endCommand() {
         output_1.output.addNewline();
+        if (this.tasks.length === 0) {
+            output_1.output.logSingleLine(`No tasks were run`);
+            return;
+        }
         if (this.failedTasks.length === 0) {
             output_1.output.addVerticalSeparatorWithoutNewLines('green');
             const bodyLines = this.cachedTasks.length > 0

package/src/tasks-runner/run-command.js

@@ -363,12 +363,14 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
 }
 async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
+    // this needs to be done before we start to run the tasks
+    const taskDetails = (0, hash_task_1.getTaskDetails)();
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
     let hasher = (0, create_task_hasher_1.createTaskHasher)(projectGraph, nxJson, runnerOptions);
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
+    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
         ...constructLifeCycles(lifeCycle),

package/src/tasks-runner/task-orchestrator.d.ts

@@ -15,6 +15,7 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private taskDetails;
     private cache;
     private forkedProcessTaskRunner;
     private tasksSchedule;

package/src/tasks-runner/task-orchestrator.js

@@ -27,7 +27,8 @@ class TaskOrchestrator {
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
-        this.cache = (0, cache_1.getCache)(this.nxJson, this.options);
+        this.taskDetails = (0, hash_task_1.getTaskDetails)();
+        this.cache = (0, cache_1.getCache)(this.options);
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // region internal state
@@ -93,7 +94,7 @@ class TaskOrchestrator {
         const task = this.taskGraph.tasks[taskId];
         const taskSpecificEnv = (0, task_env_1.getTaskSpecificEnv)(task);
         if (!task.hash) {
-            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv);
+            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv, this.taskDetails);
         }
         await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
@@ -101,7 +102,7 @@ class TaskOrchestrator {
     async processScheduledBatch(batch) {
         await Promise.all(Object.values(batch.taskGraph.tasks).map(async (task) => {
             if (!task.hash) {
-                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv);
+                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv, this.taskDetails);
             }
             await this.options.lifeCycle.scheduleTask(task);
         }));
@@ -321,6 +322,9 @@ class TaskOrchestrator {
             };
         }
         catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
             return {
                 code: 1,
             };

package/src/tasks-runner/tasks-schedule.d.ts

@@ -19,6 +19,7 @@ export declare class TasksSchedule {
     private completedTasks;
     private scheduleRequestsExecutionChain;
     private estimatedTaskTimings;
+    private projectDependencies;
     constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
     init(): Promise<void>;
     scheduleNextTasks(): Promise<void>;

package/src/tasks-runner/tasks-schedule.js

@@ -20,12 +20,16 @@ class TasksSchedule {
         this.completedTasks = new Set();
         this.scheduleRequestsExecutionChain = Promise.resolve();
         this.estimatedTaskTimings = {};
+        this.projectDependencies = {};
     }
     async init() {
         if (this.taskHistory) {
             this.estimatedTaskTimings =
                 await this.taskHistory.getEstimatedTaskTimings(Object.values(this.taskGraph.tasks).map((t) => t.target));
         }
+        for (const project of Object.values(this.taskGraph.tasks).map((t) => t.target.project)) {
+            this.projectDependencies[project] ??= (0, project_graph_utils_1.findAllProjectNodeDependencies)(project, this.reverseProjectGraph).length;
+        }
     }
     async scheduleNextTasks() {
         this.scheduleRequestsExecutionChain =
@@ -90,8 +94,8 @@ class TasksSchedule {
             // Most likely tasks with no dependencies such as test
             const project1 = this.taskGraph.tasks[taskId1].target.project;
             const project2 = this.taskGraph.tasks[taskId2].target.project;
-            const project1NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph).length;
-            const project2NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph).length;
+            const project1NodeDependencies = this.projectDependencies[project1];
+            const project2NodeDependencies = this.projectDependencies[project2];
             const dependenciesDiff = project2NodeDependencies - project1NodeDependencies;
             if (dependenciesDiff !== 0) {
                 return dependenciesDiff;

package/src/utils/git-utils.js

@@ -8,7 +8,7 @@ exports.commitChanges = commitChanges;
 exports.getLatestCommitSha = getLatestCommitSha;
 const child_process_1 = require("child_process");
 const path_1 = require("path");
-const devkit_exports_1 = require("../devkit-exports");
+const logger_1 = require("./logger");
 function execAsync(command, execOptions) {
     return new Promise((res, rej) => {
         (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
@@ -236,7 +236,7 @@ function commitChanges(commitMessage, directory) {
             // We don't want to throw during create-nx-workspace
             // because maybe there was an error when setting up git
             // initially.
-            devkit_exports_1.logger.verbose(`Git may not be set up correctly for this new workspace.
+            logger_1.logger.verbose(`Git may not be set up correctly for this new workspace.
         ${err}`);
         }
         else {

package/src/utils/plugins/output.js

@@ -47,7 +47,7 @@ function listAlsoAvailableCorePlugins(installedPlugins) {
     }
 }
 function listPowerpackPlugins() {
-    const powerpackLink = 'https://nx.dev/plugin-registry';
+    const powerpackLink = 'https://nx.dev/plugin-registry#powerpack';
     output_1.output.log({
         title: `Available Powerpack Plugins: ${powerpackLink}`,
     });