nx 16.6.0 → 16.7.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "16.6.0",
+  "version": "16.7.0-beta.0",
   "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",
+    "@nrwl/tao": "16.7.0-beta.0",
     "@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",
-    "@nx/nx-darwin-x64": "16.6.0",
-    "@nx/nx-freebsd-x64": "16.6.0",
-    "@nx/nx-linux-arm-gnueabihf": "16.6.0",
-    "@nx/nx-linux-arm64-gnu": "16.6.0",
-    "@nx/nx-linux-arm64-musl": "16.6.0",
-    "@nx/nx-linux-x64-gnu": "16.6.0",
-    "@nx/nx-linux-x64-musl": "16.6.0",
-    "@nx/nx-win32-arm64-msvc": "16.6.0",
-    "@nx/nx-win32-x64-msvc": "16.6.0"
+    "@nx/nx-darwin-arm64": "16.7.0-beta.0",
+    "@nx/nx-darwin-x64": "16.7.0-beta.0",
+    "@nx/nx-freebsd-x64": "16.7.0-beta.0",
+    "@nx/nx-linux-arm-gnueabihf": "16.7.0-beta.0",
+    "@nx/nx-linux-arm64-gnu": "16.7.0-beta.0",
+    "@nx/nx-linux-arm64-musl": "16.7.0-beta.0",
+    "@nx/nx-linux-x64-gnu": "16.7.0-beta.0",
+    "@nx/nx-linux-x64-musl": "16.7.0-beta.0",
+    "@nx/nx-win32-arm64-msvc": "16.7.0-beta.0",
+    "@nx/nx-win32-x64-msvc": "16.7.0-beta.0"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -177,5 +177,5 @@
   },
   "main": "./bin/nx.js",
   "types": "./bin/nx.d.ts",
-  "gitHead": "d02a8dbf06c85de78c0c76f64a17f10ae8085739"
+  "gitHead": "bda51652665181d38894e7ed910151e60176a9be"
 }

package/src/command-line/affected/print-affected.js

@@ -39,10 +39,10 @@ function createTasks(affectedProjectsWithTargetAndConfig, projectGraph, nxArgs,
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const defaultDependencyConfigs = (0, create_task_graph_1.mapTargetDefaultsToDependencies)(nxJson.targetDefaults);
         const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, defaultDependencyConfigs, affectedProjectsWithTargetAndConfig.map((p) => p.name), nxArgs.targets, nxArgs.configuration, overrides);
-        const hasher = new task_hasher_1.InProcessTaskHasher({}, [], projectGraph, taskGraph, nxJson, {}, file_hasher_1.fileHasher);
+        const hasher = new task_hasher_1.InProcessTaskHasher({}, [], projectGraph, nxJson, {}, file_hasher_1.fileHasher);
         const execCommand = (0, package_manager_1.getPackageManagerCommand)().exec;
         const tasks = Object.values(taskGraph.tasks);
-        yield Promise.all(tasks.map((t) => (0, hash_task_1.hashTask)(hasher, projectGraph, {}, t)));
+        yield Promise.all(tasks.map((t) => (0, hash_task_1.hashTask)(hasher, projectGraph, taskGraph, t)));
         return tasks.map((task) => ({
             id: task.id,
             overrides,

package/src/command-line/show/command-object.js

@@ -47,8 +47,8 @@ const showProjectsCommand = {
         .implies('files', 'affected')
         .implies('base', 'affected')
         .implies('head', 'affected')
-        .example('$0 show projects --patterns "apps/*"', 'Show all projects in the apps directory')
-        .example('$0 show projects --patterns "shared-*"', 'Show all projects that start with "shared-"')
+        .example('$0 show projects --projects "apps/*"', 'Show all projects in the apps directory')
+        .example('$0 show projects --projects "shared-*"', 'Show all projects that start with "shared-"')
         .example('$0 show projects --affected', 'Show affected projects in the workspace')
         .example('$0 show projects --affected --exclude *-e2e', 'Show affected projects in the workspace, excluding end-to-end projects'),
     handler: (args) => Promise.resolve().then(() => require('./show')).then((m) => m.showProjectsHandler(args)),

package/src/daemon/server/handle-hash-tasks.js

@@ -12,7 +12,6 @@ const set_hash_env_1 = require("../../hasher/set-hash-env");
  * TaskHasher has a cache inside, so keeping it around results in faster performance
  */
 let storedProjectGraph = null;
-let storedTaskGraph = null;
 let storedHasher = null;
 function handleHashTasks(payload) {
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -21,10 +20,9 @@ function handleHashTasks(payload) {
         const nxJson = (0, configuration_1.readNxJson)();
         if (projectGraph !== storedProjectGraph) {
             storedProjectGraph = projectGraph;
-            storedTaskGraph = payload.taskGraph;
-            storedHasher = new task_hasher_1.InProcessTaskHasher(projectFileMap, allWorkspaceFiles, projectGraph, payload.taskGraph, nxJson, payload.runnerOptions, file_hasher_1.fileHasher);
+            storedHasher = new task_hasher_1.InProcessTaskHasher(projectFileMap, allWorkspaceFiles, projectGraph, nxJson, payload.runnerOptions, file_hasher_1.fileHasher);
         }
-        const response = JSON.stringify(yield storedHasher.hashTasks(payload.tasks));
+        const response = JSON.stringify(yield storedHasher.hashTasks(payload.tasks, payload.taskGraph));
         return {
             response,
             description: 'handleHashTasks',

package/src/hasher/hash-task.js

@@ -23,7 +23,7 @@ function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, tas
                 (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
         })
             .map((t) => t.task);
-        const hashes = yield hasher.hashTasks(tasksToHash);
+        const hashes = yield hasher.hashTasks(tasksToHash, taskGraph);
         for (let i = 0; i < tasksToHash.length; i++) {
             tasksToHash[i].hash = hashes[i].value;
             tasksToHash[i].hashDetails = hashes[i].details;
@@ -44,7 +44,7 @@ function hashTask(hasher, projectGraph, taskGraph, task) {
                 projectsConfigurations,
                 nxJsonConfiguration: (0, nx_json_1.readNxJson)(),
             })
-            : hasher.hashTask(task));
+            : hasher.hashTask(task, taskGraph));
         task.hash = value;
         task.hashDetails = details;
     });

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

@@ -46,31 +46,39 @@ export interface Hash {
     };
 }
 export interface TaskHasher {
+    /**
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph)
+     * @param task
+     */
     hashTask(task: Task): Promise<Hash>;
+    hashTask(task: Task, taskGraph: TaskGraph): Promise<Hash>;
+    /**
+     * @deprecated use hashTasks(tasks:Task[], taskGraph: TaskGraph)
+     * @param tasks
+     */
     hashTasks(tasks: Task[]): Promise<Hash[]>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph): Promise<Hash[]>;
 }
 export type Hasher = TaskHasher;
 export declare class DaemonBasedTaskHasher implements TaskHasher {
     private readonly daemonClient;
-    private readonly taskGraph;
     private readonly runnerOptions;
-    constructor(daemonClient: DaemonClient, taskGraph: TaskGraph, runnerOptions: any);
-    hashTasks(tasks: Task[]): Promise<Hash[]>;
-    hashTask(task: Task): Promise<Hash>;
+    constructor(daemonClient: DaemonClient, runnerOptions: any);
+    hashTasks(tasks: Task[], taskGraph?: TaskGraph): Promise<Hash[]>;
+    hashTask(task: Task, taskGraph?: TaskGraph): Promise<Hash>;
 }
 export declare class InProcessTaskHasher implements TaskHasher {
     private readonly projectFileMap;
     private readonly allWorkspaceFiles;
     private readonly projectGraph;
-    private readonly taskGraph;
     private readonly nxJson;
     private readonly options;
     private readonly fileHasher;
     static version: string;
     private taskHasher;
-    constructor(projectFileMap: ProjectFileMap, allWorkspaceFiles: FileData[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: any, fileHasher: FileHasher);
-    hashTasks(tasks: Task[]): Promise<Hash[]>;
-    hashTask(task: Task): Promise<Hash>;
+    constructor(projectFileMap: ProjectFileMap, allWorkspaceFiles: FileData[], projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, options: any, fileHasher: FileHasher);
+    hashTasks(tasks: Task[], taskGraph?: TaskGraph): Promise<Hash[]>;
+    hashTask(task: Task, taskGraph?: TaskGraph): Promise<Hash>;
     private hashCommand;
 }
 export declare function getNamedInputs(nxJson: NxJsonConfiguration, project: ProjectGraphProjectNode): {

package/src/hasher/task-hasher.js

@@ -15,30 +15,28 @@ 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) {
+    constructor(daemonClient, runnerOptions) {
         this.daemonClient = daemonClient;
-        this.taskGraph = taskGraph;
         this.runnerOptions = runnerOptions;
     }
-    hashTasks(tasks) {
+    hashTasks(tasks, taskGraph) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return this.daemonClient.hashTasks(this.runnerOptions, tasks, this.taskGraph);
+            return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph);
         });
     }
-    hashTask(task) {
+    hashTask(task, taskGraph) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return (yield this.daemonClient.hashTasks(this.runnerOptions, [task], this.taskGraph))[0];
+            return (yield this.daemonClient.hashTasks(this.runnerOptions, [task], taskGraph))[0];
         });
     }
 }
 exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
 class InProcessTaskHasher {
-    constructor(projectFileMap, allWorkspaceFiles, projectGraph, taskGraph, nxJson, options, fileHasher) {
+    constructor(projectFileMap, allWorkspaceFiles, projectGraph, nxJson, options, fileHasher) {
         var _a;
         this.projectFileMap = projectFileMap;
         this.allWorkspaceFiles = allWorkspaceFiles;
         this.projectGraph = projectGraph;
-        this.taskGraph = taskGraph;
         this.nxJson = nxJson;
         this.options = options;
         this.fileHasher = fileHasher;
@@ -54,16 +52,18 @@ class InProcessTaskHasher {
             '.gitignore',
             '.nxignore',
         ].map((d) => ({ fileset: `{workspaceRoot}/${d}` }));
-        this.taskHasher = new TaskHasherImpl(nxJson, legacyRuntimeInputs, legacyFilesetInputs, this.projectFileMap, this.allWorkspaceFiles, this.projectGraph, this.taskGraph, this.fileHasher, { selectivelyHashTsConfig: (_a = this.options.selectivelyHashTsConfig) !== null && _a !== void 0 ? _a : false });
+        this.taskHasher = new TaskHasherImpl(nxJson, legacyRuntimeInputs, legacyFilesetInputs, this.projectFileMap, this.allWorkspaceFiles, this.projectGraph, this.fileHasher, { selectivelyHashTsConfig: (_a = this.options.selectivelyHashTsConfig) !== null && _a !== void 0 ? _a : false });
     }
-    hashTasks(tasks) {
+    hashTasks(tasks, taskGraph) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            return yield Promise.all(tasks.map((t) => this.hashTask(t)));
+            return yield Promise.all(tasks.map((t) => this.hashTask(t, taskGraph)));
         });
     }
-    hashTask(task) {
+    hashTask(task, taskGraph) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            const res = yield this.taskHasher.hashTask(task, [task.target.project]);
+            const res = yield this.taskHasher.hashTask(task, taskGraph, [
+                task.target.project,
+            ]);
             const command = this.hashCommand(task);
             return {
                 value: (0, file_hasher_1.hashArray)([res.value, command]),
@@ -104,14 +104,13 @@ const DEFAULT_INPUTS = [
     },
 ];
 class TaskHasherImpl {
-    constructor(nxJson, legacyRuntimeInputs, legacyFilesetInputs, projectFileMap, allWorkspaceFiles, projectGraph, taskGraph, fileHasher, options) {
+    constructor(nxJson, legacyRuntimeInputs, legacyFilesetInputs, projectFileMap, allWorkspaceFiles, projectGraph, fileHasher, options) {
         this.nxJson = nxJson;
         this.legacyRuntimeInputs = legacyRuntimeInputs;
         this.legacyFilesetInputs = legacyFilesetInputs;
         this.projectFileMap = projectFileMap;
         this.allWorkspaceFiles = allWorkspaceFiles;
         this.projectGraph = projectGraph;
-        this.taskGraph = taskGraph;
         this.fileHasher = fileHasher;
         this.options = options;
         this.filesetHashes = {};
@@ -121,11 +120,11 @@ class TaskHasherImpl {
         // External Dependencies are all calculated up front in a deterministic order
         this.calculateExternalDependencyHashes();
     }
-    hashTask(task, visited) {
+    hashTask(task, taskGraph, visited) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             return Promise.resolve().then(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 const { selfInputs, depsInputs, depsOutputs, projectInputs } = getInputs(task, this.projectGraph, this.nxJson);
-                const selfAndInputs = yield this.hashSelfAndDepsInputs(task.target.project, task, selfInputs, depsInputs, depsOutputs, projectInputs, visited);
+                const selfAndInputs = yield this.hashSelfAndDepsInputs(task.target.project, task, selfInputs, depsInputs, depsOutputs, projectInputs, taskGraph, visited);
                 const target = this.hashTarget(task.target.project, task.target.target, selfInputs);
                 if (target) {
                     return this.combinePartialHashes([selfAndInputs, target]);
@@ -134,7 +133,7 @@ class TaskHasherImpl {
             }));
         });
     }
-    hashNamedInputForDependencies(projectName, task, namedInput, visited) {
+    hashNamedInputForDependencies(projectName, task, namedInput, taskGraph, visited) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const projectNode = this.projectGraph.nodes[projectName];
             const namedInputs = Object.assign(Object.assign({ default: [{ fileset: '{projectRoot}/**/*' }] }, this.nxJson.namedInputs), projectNode.data.namedInputs);
@@ -142,18 +141,18 @@ class TaskHasherImpl {
             const selfInputs = expandedInputs.filter(isSelfInput);
             const depsOutputs = expandedInputs.filter(isDepsOutput);
             const depsInputs = [{ input: namedInput, dependencies: true }]; // true is boolean by default
-            return this.hashSelfAndDepsInputs(projectName, task, selfInputs, depsInputs, depsOutputs, [], visited);
+            return this.hashSelfAndDepsInputs(projectName, task, selfInputs, depsInputs, depsOutputs, [], taskGraph, visited);
         });
     }
-    hashSelfAndDepsInputs(projectName, task, selfInputs, depsInputs, depsOutputs, projectInputs, visited) {
+    hashSelfAndDepsInputs(projectName, task, selfInputs, depsInputs, depsOutputs, projectInputs, taskGraph, visited) {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             const projectGraphDeps = (_a = this.projectGraph.dependencies[projectName]) !== null && _a !== void 0 ? _a : [];
             // we don't want random order of dependencies to change the hash
             projectGraphDeps.sort((a, b) => a.target.localeCompare(b.target));
             const self = yield this.hashSingleProjectInputs(projectName, selfInputs);
-            const deps = yield this.hashDepsInputs(task, depsInputs, projectGraphDeps, visited);
-            const depsOut = yield this.hashDepsOutputs(task, depsOutputs);
+            const deps = yield this.hashDepsInputs(task, depsInputs, projectGraphDeps, taskGraph, visited);
+            const depsOut = yield this.hashDepsOutputs(task, depsOutputs, taskGraph);
             const projects = yield this.hashProjectInputs(projectInputs);
             return this.combinePartialHashes([
                 ...self,
@@ -176,7 +175,7 @@ class TaskHasherImpl {
         const value = (0, file_hasher_1.hashArray)(hashValues);
         return { value, details };
     }
-    hashDepsInputs(task, inputs, projectGraphDeps, visited) {
+    hashDepsInputs(task, inputs, projectGraphDeps, taskGraph, visited) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             return (yield Promise.all(inputs.map((input) => tslib_1.__awaiter(this, void 0, void 0, function* () {
                 return yield Promise.all(projectGraphDeps.map((d) => tslib_1.__awaiter(this, void 0, void 0, function* () {
@@ -186,7 +185,7 @@ class TaskHasherImpl {
                     else {
                         visited.push(d.target);
                         if (this.projectGraph.nodes[d.target]) {
-                            return yield this.hashNamedInputForDependencies(d.target, task, input.input || 'default', visited);
+                            return yield this.hashNamedInputForDependencies(d.target, task, input.input || 'default', taskGraph, visited);
                         }
                         else {
                             return this.getExternalDependencyHash(d.target);
@@ -198,27 +197,27 @@ class TaskHasherImpl {
                 .filter((r) => !!r);
         });
     }
-    hashDepsOutputs(task, depsOutputs) {
+    hashDepsOutputs(task, depsOutputs, taskGraph) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             if (depsOutputs.length === 0) {
                 return [];
             }
             const result = [];
             for (const { dependentTasksOutputFiles, transitive } of depsOutputs) {
-                result.push(...(yield this.hashDepOuputs(task, dependentTasksOutputFiles, transitive)));
+                result.push(...(yield this.hashDepOuputs(task, dependentTasksOutputFiles, taskGraph, transitive)));
             }
             return result;
         });
     }
-    hashDepOuputs(task, dependentTasksOutputFiles, transitive) {
+    hashDepOuputs(task, dependentTasksOutputFiles, taskGraph, transitive) {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             // task has no dependencies
-            if (!this.taskGraph.dependencies[task.id]) {
+            if (!taskGraph.dependencies[task.id]) {
                 return [];
             }
             const partialHashes = [];
-            for (const d of this.taskGraph.dependencies[task.id]) {
-                const childTask = this.taskGraph.tasks[d];
+            for (const d of taskGraph.dependencies[task.id]) {
+                const childTask = taskGraph.tasks[d];
                 const outputs = (0, utils_1.getOutputsForTargetAndConfiguration)(childTask, this.projectGraph.nodes[childTask.target.project]);
                 const { getFilesForOutputs } = require('../native');
                 const outputFiles = getFilesForOutputs(workspace_root_1.workspaceRoot, outputs);
@@ -235,7 +234,7 @@ class TaskHasherImpl {
                     details: hashDetails,
                 });
                 if (transitive) {
-                    partialHashes.push(...(yield this.hashDepOuputs(childTask, dependentTasksOutputFiles, transitive)));
+                    partialHashes.push(...(yield this.hashDepOuputs(childTask, dependentTasksOutputFiles, taskGraph, transitive)));
                 }
             }
             return partialHashes;

package/src/plugins/js/project-graph/build-dependencies/build-dependencies.js

@@ -13,8 +13,7 @@ function buildExplicitDependencies(jsPluginConfig, ctx, builder) {
     // files we need to process is >= 100 and there are more than 2 CPUs
     // to be able to use at least 2 workers (1 worker per CPU and
     // 1 CPU for the main thread)
-    if ((process.env.NX_NATIVE_TS_DEPS &&
-        process.env.NX_NATIVE_TS_DEPS !== 'false') ||
+    if (process.env.NX_NATIVE_TS_DEPS !== 'false' ||
         jsPluginConfig.analyzeSourceFiles === false ||
         totalNumOfFilesToProcess < 100 ||
         getNumberOfWorkers() <= 2) {

package/src/plugins/js/project-graph/build-dependencies/explicit-project-dependencies.js

@@ -4,10 +4,11 @@ exports.buildExplicitTypeScriptDependencies = void 0;
 const typescript_import_locator_1 = require("./typescript-import-locator");
 const target_project_locator_1 = require("./target-project-locator");
 const project_graph_1 = require("../../../../config/project-graph");
+const path_1 = require("path");
+const workspace_root_1 = require("../../../../utils/workspace-root");
 function buildExplicitTypeScriptDependencies(graph, filesToProcess) {
     let results;
-    if (process.env.NX_NATIVE_TS_DEPS &&
-        process.env.NX_NATIVE_TS_DEPS !== 'false') {
+    if (process.env.NX_NATIVE_TS_DEPS !== 'false') {
         results = buildExplicitTypeScriptDependenciesWithSwc(filesToProcess, graph);
     }
     else {
@@ -66,7 +67,7 @@ function buildExplicitTypeScriptDependenciesWithSwc(projectFileMap, graph) {
         (_a = filesToProcess[project]) !== null && _a !== void 0 ? _a : (filesToProcess[project] = []);
         for (const { file } of fileData) {
             if (moduleExtensions.some((ext) => file.endsWith(ext))) {
-                filesToProcess[project].push(file);
+                filesToProcess[project].push((0, path_1.join)(workspace_root_1.workspaceRoot, file));
             }
         }
     }
@@ -74,7 +75,7 @@ function buildExplicitTypeScriptDependenciesWithSwc(projectFileMap, graph) {
     const imports = findImports(filesToProcess);
     for (const { sourceProject, file, staticImportExpressions, dynamicImportExpressions, } of imports) {
         for (const importExpr of staticImportExpressions) {
-            const dependency = convertImportToDependency(importExpr, file, sourceProject, project_graph_1.DependencyType.static, targetProjectLocator);
+            const dependency = convertImportToDependency(importExpr, (0, path_1.relative)(workspace_root_1.workspaceRoot, file), sourceProject, project_graph_1.DependencyType.static, targetProjectLocator);
             // TODO: These edges technically should be allowed but we need to figure out how to separate config files out from root
             if (isRoot(graph, dependency.sourceProjectName) ||
                 !isRoot(graph, dependency.targetProjectName)) {
@@ -82,7 +83,7 @@ function buildExplicitTypeScriptDependenciesWithSwc(projectFileMap, graph) {
             }
         }
         for (const importExpr of dynamicImportExpressions) {
-            const dependency = convertImportToDependency(importExpr, file, sourceProject, project_graph_1.DependencyType.dynamic, targetProjectLocator);
+            const dependency = convertImportToDependency(importExpr, (0, path_1.relative)(workspace_root_1.workspaceRoot, file), sourceProject, project_graph_1.DependencyType.dynamic, targetProjectLocator);
             // TODO: These edges technically should be allowed but we need to figure out how to separate config files out from root
             if (isRoot(graph, dependency.sourceProjectName) ||
                 !isRoot(graph, dependency.targetProjectName)) {

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

@@ -131,11 +131,11 @@ function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson,
         const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
         let hasher;
         if (client_1.daemonClient.enabled()) {
-            hasher = new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, taskGraph, runnerOptions);
+            hasher = new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
         }
         else {
             const { projectFileMap, allWorkspaceFiles } = (0, build_project_graph_1.getProjectFileMap)();
-            hasher = new task_hasher_1.InProcessTaskHasher(projectFileMap, allWorkspaceFiles, projectGraph, taskGraph, nxJson, runnerOptions, file_hasher_1.fileHasher);
+            hasher = new task_hasher_1.InProcessTaskHasher(projectFileMap, allWorkspaceFiles, projectGraph, nxJson, runnerOptions, file_hasher_1.fileHasher);
         }
         // 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
@@ -150,7 +150,32 @@ function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson,
             nxJson,
             nxArgs,
             taskGraph,
-            hasher,
+            hasher: {
+                hashTask(task, taskGraph_) {
+                    if (!taskGraph_) {
+                        output_1.output.warn({
+                            title: `TaskGraph is now required as an argument to hashTasks`,
+                            bodyLines: [
+                                `The TaskGraph object can be retrieved from the context`,
+                            ],
+                        });
+                        taskGraph_ = taskGraph;
+                    }
+                    return hasher.hashTask(task, taskGraph_);
+                },
+                hashTasks(task, taskGraph_) {
+                    if (!taskGraph_) {
+                        output_1.output.warn({
+                            title: `TaskGraph is now required as an argument to hashTasks`,
+                            bodyLines: [
+                                `The TaskGraph object can be retrieved from the context`,
+                            ],
+                        });
+                        taskGraph_ = taskGraph;
+                    }
+                    return hasher.hashTasks(task, taskGraph_);
+                },
+            },
             daemon: client_1.daemonClient,
         });
         let anyFailures;