nx 20.8.4 → 22.7.7

package/dist/src/generators/utils/project-configuration.js

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateNxJson = exports.readNxJson = void 0;
+exports.addProjectConfiguration = addProjectConfiguration;
+exports.updateProjectConfiguration = updateProjectConfiguration;
+exports.removeProjectConfiguration = removeProjectConfiguration;
+exports.readProjectConfiguration = readProjectConfiguration;
+exports.getProjects = getProjects;
+exports.getRelativeProjectJsonSchemaPath = getRelativeProjectJsonSchemaPath;
+const minimatch_1 = require("minimatch");
+const path_1 = require("path");
+const package_json_1 = require("../../plugins/package-json");
+const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
+const angular_json_1 = require("../../adapter/angular-json");
+const project_nodes_manager_1 = require("../../project-graph/utils/project-configuration/project-nodes-manager");
+const workspace_context_1 = require("../../utils/workspace-context");
+const output_1 = require("../../utils/output");
+const path_2 = require("../../utils/path");
+const json_1 = require("./json");
+const to_project_name_1 = require("../../config/to-project-name");
+var nx_json_1 = require("./nx-json");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_1.readNxJson; } });
+Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_1.updateNxJson; } });
+/**
+ * Adds project configuration to the Nx workspace.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ * @param standalone - whether the project is configured in workspace.json or not
+ */
+function addProjectConfiguration(tree, projectName, projectConfiguration, standalone = true) {
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    if (!standalone) {
+        output_1.output.warn({
+            title: 'Nx only supports standalone projects. Setting standalone to false is ignored.',
+        });
+    }
+    if (tree.exists(projectConfigFile)) {
+        throw new Error(`Cannot create a new project ${projectName} at ${projectConfiguration.root}. A project already exists in this directory.`);
+    }
+    delete projectConfiguration.$schema;
+    handleEmptyTargets(projectName, projectConfiguration);
+    (0, json_1.writeJson)(tree, projectConfigFile, {
+        name: projectName,
+        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
+        ...projectConfiguration,
+        root: undefined,
+    });
+}
+/**
+ * Updates the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ */
+function updateProjectConfiguration(tree, projectName, projectConfiguration) {
+    if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json'))) {
+        updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration);
+    }
+    else if (tree.exists((0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json'))) {
+        updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration);
+    }
+    else {
+        throw new Error(`Cannot update Project ${projectName} at ${projectConfiguration.root}. It either doesn't exist yet, or may not use project.json for configuration. Use \`addProjectConfiguration()\` instead if you want to create a new project.`);
+    }
+}
+function updateProjectConfigurationInPackageJson(tree, projectName, projectConfiguration) {
+    const packageJsonFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'package.json');
+    const packageJson = (0, json_1.readJson)(tree, packageJsonFile);
+    projectConfiguration.name = projectName;
+    if (packageJson.name === projectConfiguration.name) {
+        delete projectConfiguration.name;
+    }
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        delete projectConfiguration.targets;
+    }
+    packageJson.nx = {
+        ...packageJson.nx,
+        ...projectConfiguration,
+    };
+    // We don't want to ever this since it is inferred
+    delete packageJson.nx.root;
+    // Only set `nx` property in `package.json` if it is a root project (necessary to mark it as Nx project),
+    // or if there are properties to be set. If it is empty, then avoid it so we don't add unnecessary boilerplate.
+    if (projectConfiguration.root === '.' ||
+        Object.keys(packageJson.nx).length > 0) {
+        (0, json_1.writeJson)(tree, packageJsonFile, packageJson);
+    }
+}
+function updateProjectConfigurationInProjectJson(tree, projectName, projectConfiguration) {
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    handleEmptyTargets(projectName, projectConfiguration);
+    (0, json_1.writeJson)(tree, projectConfigFile, {
+        name: projectConfiguration.name ?? projectName,
+        $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
+        ...projectConfiguration,
+        root: undefined,
+    });
+}
+/**
+ * Removes the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ */
+function removeProjectConfiguration(tree, projectName) {
+    const projectConfiguration = readProjectConfiguration(tree, projectName);
+    if (!projectConfiguration) {
+        throw new Error(`Cannot delete Project ${projectName}`);
+    }
+    const projectConfigFile = (0, path_2.joinPathFragments)(projectConfiguration.root, 'project.json');
+    if (tree.exists(projectConfigFile)) {
+        tree.delete(projectConfigFile);
+    }
+}
+/**
+ * Reads a project configuration.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @throws If supplied projectName cannot be found
+ */
+function readProjectConfiguration(tree, projectName) {
+    const allProjects = readAndCombineAllProjectConfigurations(tree);
+    if (!allProjects[projectName]) {
+        // temporary polyfill to make sure our generators work for existing angularcli workspaces
+        if (tree.exists('angular.json')) {
+            const angularJson = toNewFormat((0, json_1.readJson)(tree, 'angular.json'));
+            if (angularJson.projects[projectName])
+                return angularJson.projects[projectName];
+        }
+        throw new Error(`Cannot find configuration for '${projectName}'`);
+    }
+    return allProjects[projectName];
+}
+/**
+ * Get a map of all projects in a workspace.
+ *
+ * Use {@link readProjectConfiguration} if only one project is needed.
+ */
+function getProjects(tree) {
+    let allProjects = readAndCombineAllProjectConfigurations(tree);
+    // temporary polyfill to make sure our generators work for existing angularcli workspaces
+    if (tree.exists('angular.json')) {
+        const angularJson = toNewFormat((0, json_1.readJson)(tree, 'angular.json'));
+        allProjects = { ...allProjects, ...angularJson.projects };
+    }
+    return new Map(Object.keys(allProjects || {}).map((projectName) => {
+        return [projectName, allProjects[projectName]];
+    }));
+}
+function getRelativeProjectJsonSchemaPath(tree, project) {
+    return (0, path_2.normalizePath)((0, path_1.relative)((0, path_1.join)(tree.root, project.root), (0, path_1.join)(tree.root, 'node_modules/nx/schemas/project-schema.json')));
+}
+function readAndCombineAllProjectConfigurations(tree) {
+    /**
+     * We can't update projects that come from plugins anyways, so we are going
+     * to ignore them for now. Plugins should add their own add/create/update methods
+     * if they would like to use devkit to update inferred projects.
+     */
+    const patterns = [
+        '**/project.json',
+        'project.json',
+        ...(0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p, { expectComments: true }), (p) => {
+            const content = tree.read(p, 'utf-8');
+            const { load } = require('@zkochan/js-yaml');
+            return load(content, { filename: p });
+        }, (p) => tree.exists(p)),
+    ];
+    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(tree.root, patterns);
+    const createdFiles = findCreatedProjectFiles(tree, patterns);
+    const deletedFiles = findDeletedProjectFiles(tree, patterns);
+    // Ensure we don't duplicate files that are both globbed and in tree changes
+    const allProjectFiles = new Set([...globbedFiles, ...createdFiles]);
+    const projectFiles = Array.from(allProjectFiles).filter((r) => deletedFiles.indexOf(r) === -1);
+    const rootMap = {};
+    for (const projectFile of projectFiles) {
+        if ((0, path_1.basename)(projectFile) === 'project.json') {
+            const json = (0, json_1.readJson)(tree, projectFile);
+            const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
+            if (!config.name) {
+                try {
+                    const packageJson = (0, json_1.readJson)(tree, (0, path_2.joinPathFragments)(config.root, 'package.json'));
+                    if (packageJson.name) {
+                        config.name = packageJson.name;
+                    }
+                }
+                catch {
+                    // Maybe no package json, is ok.
+                }
+                config.name ??= (0, to_project_name_1.toProjectName)(projectFile);
+            }
+            (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
+        }
+        if ((0, path_1.basename)(projectFile) === 'package.json') {
+            const packageJson = (0, json_1.readJson)(tree, projectFile);
+            // We don't want to have all of the extra inferred stuff in here, as
+            // when generators update the project they shouldn't inline that stuff.
+            // so rather than using `buildProjectFromPackageJson` and stripping it out
+            // we are going to build the config manually.
+            const config = {
+                root: (0, path_1.dirname)(projectFile),
+                name: packageJson.name ?? (0, to_project_name_1.toProjectName)(projectFile),
+                ...packageJson.nx,
+            };
+            if (!rootMap[config.root]) {
+                (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
+                // Inferred targets, tags, etc don't show up when running generators
+                // This is to help avoid running into issues when trying to update the workspace
+                config, undefined, undefined, true);
+            }
+        }
+    }
+    return (0, project_nodes_manager_1.readProjectConfigurationsFromRootMap)(rootMap);
+}
+/**
+ * Used to ensure that projects created during
+ * the same devkit generator run show up when
+ * there is no project.json file, as `glob`
+ * cannot find them.
+ *
+ * We exclude the root `package.json` from this list unless
+ * considered a project during workspace generation
+ */
+function findCreatedProjectFiles(tree, globPatterns) {
+    const createdProjectFiles = [];
+    for (const change of tree.listChanges()) {
+        // Include both CREATE and UPDATE changes to handle project files
+        // created during generator callbacks (which are marked as UPDATE
+        // since the tree has already been flushed to disk)
+        if (change.type === 'CREATE' || change.type === 'UPDATE') {
+            const fileName = (0, path_1.basename)(change.path);
+            if (globPatterns.some((pattern) => (0, minimatch_1.minimatch)(change.path, pattern, { dot: true }))) {
+                createdProjectFiles.push(change.path);
+            }
+            else if (fileName === 'package.json') {
+                try {
+                    const contents = JSON.parse(change.content.toString());
+                    if (contents.nx) {
+                        createdProjectFiles.push(change.path);
+                    }
+                }
+                catch { }
+            }
+        }
+    }
+    return createdProjectFiles.map(path_2.normalizePath);
+}
+/**
+ * Used to ensure that projects created during
+ * the same devkit generator run show up when
+ * there is no project.json file, as `glob`
+ * cannot find them.
+ */
+function findDeletedProjectFiles(tree, globPatterns) {
+    return tree
+        .listChanges()
+        .filter((f) => {
+        return (f.type === 'DELETE' &&
+            globPatterns.some((pattern) => (0, minimatch_1.minimatch)(f.path, pattern)));
+    })
+        .map((r) => r.path);
+}
+function toNewFormat(w) {
+    const projects = {};
+    Object.keys(w.projects || {}).forEach((name) => {
+        if (typeof w.projects[name] === 'string')
+            return;
+        const projectConfig = w.projects[name];
+        if (projectConfig.architect) {
+            (0, angular_json_1.renamePropertyWithStableKeys)(projectConfig, 'architect', 'targets');
+        }
+        if (projectConfig.schematics) {
+            (0, angular_json_1.renamePropertyWithStableKeys)(projectConfig, 'schematics', 'generators');
+        }
+        Object.values(projectConfig.targets || {}).forEach((target) => {
+            if (target.builder !== undefined) {
+                (0, angular_json_1.renamePropertyWithStableKeys)(target, 'builder', 'executor');
+            }
+        });
+        projects[name] = projectConfig;
+    });
+    w.projects = projects;
+    if (w.schematics) {
+        (0, angular_json_1.renamePropertyWithStableKeys)(w, 'schematics', 'generators');
+    }
+    if (w.version !== 2) {
+        w.version = 2;
+    }
+    return w;
+}
+function handleEmptyTargets(projectName, projectConfiguration) {
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        // Re-order `targets` to appear after the `// target` comment.
+        delete projectConfiguration.targets;
+        projectConfiguration['// targets'] =
+            `to see all targets run: nx show project ${projectName} --web`;
+        projectConfiguration.targets = {};
+    }
+    else {
+        delete projectConfiguration['// targets'];
+    }
+}

package/dist/src/hasher/hash-plan-inspector.d.ts

@@ -0,0 +1,33 @@
+import type { Target } from '../command-line/run/run';
+import { NxJsonConfiguration, TargetDependencies } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { HashInputs } from '../native';
+export declare class HashPlanInspector {
+    private projectGraph;
+    private readonly workspaceRootPath;
+    private readonly projectGraphRef;
+    private planner;
+    private inspector;
+    private readonly nxJson;
+    constructor(projectGraph: ProjectGraph, workspaceRootPath?: string, nxJson?: NxJsonConfiguration);
+    init(): Promise<void>;
+    /**
+     * This is a lower level method which will inspect the hash plan for a set of tasks.
+     */
+    inspectHashPlan(projectNames: string[], targets: string[], configuration?: string, overrides?: Object, extraTargetDependencies?: TargetDependencies, excludeTaskDependencies?: boolean): Record<string, string[]>;
+    /**
+     * This inspects tasks involved in the execution of a task, including its dependencies by default.
+     * @deprecated Prefer inspectTaskInputs
+     */
+    inspectTask({ project, target, configuration }: Target, parsedArgs?: {
+        [k: string]: any;
+    }, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, excludeTaskDependencies?: boolean): Record<string, string[]>;
+    /**
+     * Like inspectTask() but returns structured HashInputs objects instead of flat strings.
+     * Each input is categorized into files, runtime, environment, depOutputs, or external.
+     */
+    inspectTaskInputs({ project, target, configuration }: Target, parsedArgs?: {
+        [k: string]: any;
+    }, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, excludeTaskDependencies?: boolean): Record<string, HashInputs>;
+}

package/dist/src/hasher/hash-plan-inspector.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashPlanInspector = void 0;
+const nx_json_1 = require("../config/nx-json");
+const native_1 = require("../native");
+const transform_objects_1 = require("../native/transform-objects");
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const create_task_graph_1 = require("../tasks-runner/create-task-graph");
+const command_line_utils_1 = require("../utils/command-line-utils");
+const workspace_context_1 = require("../utils/workspace-context");
+const workspace_root_1 = require("../utils/workspace-root");
+class HashPlanInspector {
+    constructor(projectGraph, workspaceRootPath = workspace_root_1.workspaceRoot, nxJson) {
+        this.projectGraph = projectGraph;
+        this.workspaceRootPath = workspaceRootPath;
+        this.nxJson = nxJson ?? (0, nx_json_1.readNxJson)(this.workspaceRootPath);
+        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(this.projectGraph));
+        this.planner = new native_1.HashPlanner(this.nxJson, this.projectGraphRef);
+    }
+    async init() {
+        const projectRootMap = (0, find_project_for_path_1.createProjectRootMappings)(this.projectGraph.nodes);
+        const map = Object.fromEntries(projectRootMap.entries());
+        const { externalReferences } = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(this.workspaceRootPath, map, false);
+        this.inspector = new native_1.HashPlanInspector(externalReferences.allWorkspaceFiles, externalReferences.projectFiles, this.workspaceRootPath);
+    }
+    /**
+     * This is a lower level method which will inspect the hash plan for a set of tasks.
+     */
+    inspectHashPlan(projectNames, targets, configuration, overrides = {}, extraTargetDependencies = {}, excludeTaskDependencies = false) {
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(this.projectGraph, extraTargetDependencies, projectNames, targets, configuration, overrides, excludeTaskDependencies);
+        // Generate task IDs for ALL tasks in the task graph (including dependencies)
+        const taskIds = Object.keys(taskGraph.tasks);
+        const plansReference = this.planner.getPlansReference(taskIds, taskGraph);
+        return this.inspector.inspect(plansReference);
+    }
+    /**
+     * This inspects tasks involved in the execution of a task, including its dependencies by default.
+     * @deprecated Prefer inspectTaskInputs
+     */
+    inspectTask({ project, target, configuration }, parsedArgs = {}, extraTargetDependencies = {}, excludeTaskDependencies = false) {
+        // Mirror the exact flow from run-one.ts
+        const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
+            ...parsedArgs,
+            configuration: configuration,
+            targets: [target],
+        }, 'run-one', { printWarnings: false }, this.nxJson);
+        // Create task graph exactly like run-one.ts does via createTaskGraphAndRunValidations
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(this.projectGraph, extraTargetDependencies, [project], nxArgs.targets, nxArgs.configuration, overrides, excludeTaskDependencies);
+        // Generate task IDs for ALL tasks in the task graph (including dependencies)
+        const taskIds = Object.keys(taskGraph.tasks);
+        const plansReference = this.planner.getPlansReference(taskIds, taskGraph);
+        return this.inspector.inspect(plansReference);
+    }
+    /**
+     * Like inspectTask() but returns structured HashInputs objects instead of flat strings.
+     * Each input is categorized into files, runtime, environment, depOutputs, or external.
+     */
+    inspectTaskInputs({ project, target, configuration }, parsedArgs = {}, extraTargetDependencies = {}, excludeTaskDependencies = false) {
+        const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
+            ...parsedArgs,
+            configuration: configuration,
+            targets: [target],
+        }, 'run-one', { printWarnings: false }, this.nxJson);
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(this.projectGraph, extraTargetDependencies, [project], nxArgs.targets, nxArgs.configuration, overrides, excludeTaskDependencies);
+        const taskIds = Object.keys(taskGraph.tasks);
+        const plansReference = this.planner.getPlansReference(taskIds, taskGraph);
+        return this.inspector.inspectInputs(plansReference);
+    }
+}
+exports.HashPlanInspector = HashPlanInspector;

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

@@ -0,0 +1,17 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TaskDetails } from '../native';
+import { TaskHasher } from './task-hasher';
+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>;
+/**
+ * Batch-hash `tasks`. `perTaskEnvs` must contain an entry keyed by
+ * `task.id` for every task — the per-task env is what each task's
+ * custom hasher sees and what the built-in hasher reads
+ * `HashInstruction::Environment` inputs against. Callers that
+ * genuinely want to hash against a single shared env should build
+ * `{ [task.id]: env }` for every task.
+ */
+export declare function hashTasks(hasher: TaskHasher, projectGraph: ProjectGraph, taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, taskDetails: TaskDetails | null, tasksToHashOverride?: Task[]): Promise<void>;

package/dist/src/hasher/hash-task.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTaskDetails = getTaskDetails;
+exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
+exports.hashTask = hashTask;
+exports.hashTasks = hashTasks;
+const nx_json_1 = require("../config/nx-json");
+const native_1 = require("../native");
+const project_graph_1 = require("../project-graph/project-graph");
+const task_io_service_1 = require("../tasks-runner/task-io-service");
+const task_env_1 = require("../tasks-runner/task-env");
+const utils_1 = require("../tasks-runner/utils");
+const db_connection_1 = require("../utils/db-connection");
+const task_hasher_1 = require("./task-hasher");
+let taskDetails;
+function getTaskDetails() {
+    // TODO: Remove when wasm supports sqlite
+    if (native_1.IS_WASM) {
+        return null;
+    }
+    if (!taskDetails) {
+        taskDetails = new native_1.TaskDetails((0, db_connection_1.getDbConnection)());
+    }
+    return taskDetails;
+}
+async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson, tasksDetails) {
+    performance.mark('hashMultipleTasks:start');
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    const tasks = Object.values(taskGraph.tasks);
+    const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
+        const customHasher = (0, utils_1.getCustomHasher)(task, projects);
+        return { task, customHasher };
+    }));
+    const tasksToHash = tasksWithHashers
+        .filter(({ task, customHasher }) => {
+        // If a task has a custom hasher, it might depend on the outputs of other tasks
+        if (customHasher) {
+            return false;
+        }
+        return !(taskGraph.dependencies[task.id].length > 0 &&
+            (0, task_hasher_1.getInputs)(task, projectGraph, nxJson).depsOutputs.length > 0);
+    })
+        .map((t) => t.task);
+    const perTaskEnvs = {};
+    for (const task of tasksToHash) {
+        perTaskEnvs[task.id] = (0, task_env_1.getTaskSpecificEnv)(task, projectGraph);
+    }
+    const hashes = await hasher.hashTasks(tasksToHash, taskGraph, perTaskEnvs);
+    const ioService = (0, task_io_service_1.getTaskIOService)();
+    const hasInputSubscribers = ioService.hasTaskInputSubscribers();
+    for (let i = 0; i < tasksToHash.length; i++) {
+        tasksToHash[i].hash = hashes[i].value;
+        tasksToHash[i].hashDetails = hashes[i].details;
+        // Notify TaskIOService of hash inputs
+        if (hasInputSubscribers && hashes[i].inputs) {
+            ioService.notifyTaskInputs(tasksToHash[i].id, hashes[i].inputs);
+        }
+    }
+    if (tasksDetails?.recordTaskDetails) {
+        tasksDetails.recordTaskDetails(tasksToHash.map((task) => ({
+            hash: task.hash,
+            project: task.target.project,
+            target: task.target.target,
+            configuration: task.target.configuration,
+        })));
+    }
+    performance.mark('hashMultipleTasks:end');
+    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
+}
+async function hashTask(hasher, projectGraph, taskGraph, task, env, taskDetails) {
+    performance.mark('hashSingleTask:start');
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
+    const { value, details, inputs } = await (customHasher
+        ? customHasher(task, {
+            hasher,
+            projectGraph,
+            taskGraph,
+            workspaceConfig: projectsConfigurations, // to make the change non-breaking. Remove after v19
+            projectsConfigurations,
+            nxJsonConfiguration: (0, nx_json_1.readNxJson)(),
+            env,
+        })
+        : hasher.hashTask(task, taskGraph, env));
+    task.hash = value;
+    task.hashDetails = details;
+    // Notify TaskIOService of hash inputs
+    const ioService = (0, task_io_service_1.getTaskIOService)();
+    if (ioService.hasTaskInputSubscribers() && inputs) {
+        ioService.notifyTaskInputs(task.id, inputs);
+    }
+    if (taskDetails?.recordTaskDetails) {
+        taskDetails.recordTaskDetails([
+            {
+                hash: task.hash,
+                project: task.target.project,
+                target: task.target.target,
+                configuration: task.target.configuration,
+            },
+        ]);
+    }
+    performance.mark('hashSingleTask:end');
+    performance.measure('hashSingleTask', 'hashSingleTask:start', 'hashSingleTask:end');
+}
+/**
+ * Batch-hash `tasks`. `perTaskEnvs` must contain an entry keyed by
+ * `task.id` for every task — the per-task env is what each task's
+ * custom hasher sees and what the built-in hasher reads
+ * `HashInstruction::Environment` inputs against. Callers that
+ * genuinely want to hash against a single shared env should build
+ * `{ [task.id]: env }` for every task.
+ */
+async function hashTasks(hasher, projectGraph, taskGraph, perTaskEnvs, taskDetails, tasksToHashOverride) {
+    performance.mark('hashMultipleTasks:start');
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const tasks = (tasksToHashOverride ?? Object.values(taskGraph.tasks)).filter((task) => !task.hash);
+    // Separate tasks with custom hashers from those without
+    const tasksWithCustomHashers = [];
+    const tasksWithoutCustomHashers = [];
+    for (const task of tasks) {
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
+        if (customHasher) {
+            tasksWithCustomHashers.push(task);
+        }
+        else {
+            tasksWithoutCustomHashers.push(task);
+        }
+    }
+    // Hash tasks with custom hashers individually
+    const ioService = (0, task_io_service_1.getTaskIOService)();
+    const hasInputSubscribers = ioService.hasTaskInputSubscribers();
+    const customHasherPromises = tasksWithCustomHashers.map(async (task) => {
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectsConfigurations.projects);
+        const { value, details, inputs } = await customHasher(task, {
+            hasher,
+            projectGraph,
+            taskGraph,
+            workspaceConfig: projectsConfigurations,
+            projectsConfigurations,
+            nxJsonConfiguration: nxJson,
+            env: perTaskEnvs[task.id],
+        });
+        task.hash = value;
+        task.hashDetails = details;
+        // Notify TaskIOService of hash inputs
+        if (hasInputSubscribers && inputs) {
+            ioService.notifyTaskInputs(task.id, inputs);
+        }
+    });
+    // Hash tasks without custom hashers in batch
+    let batchHashPromise = Promise.resolve();
+    if (tasksWithoutCustomHashers.length > 0) {
+        batchHashPromise = hasher
+            .hashTasks(tasksWithoutCustomHashers, taskGraph, perTaskEnvs)
+            .then((hashes) => {
+            for (let i = 0; i < tasksWithoutCustomHashers.length; i++) {
+                tasksWithoutCustomHashers[i].hash = hashes[i].value;
+                tasksWithoutCustomHashers[i].hashDetails = hashes[i].details;
+                // Notify TaskIOService of hash inputs
+                if (hasInputSubscribers && hashes[i].inputs) {
+                    ioService.notifyTaskInputs(tasksWithoutCustomHashers[i].id, hashes[i].inputs);
+                }
+            }
+        });
+    }
+    await Promise.all([...customHasherPromises, batchHashPromise]);
+    if (taskDetails?.recordTaskDetails) {
+        // Guard against a custom hasher resolving with a falsy value —
+        // the built-in batch hasher always produces a hash, but user-written
+        // custom hashers are untrusted and an empty/undefined hash would
+        // violate the task_details schema downstream.
+        const hashedTasks = [];
+        for (const t of tasks) {
+            if (!t.hash) {
+                continue;
+            }
+            hashedTasks.push({
+                hash: t.hash,
+                project: t.target.project,
+                target: t.target.target,
+                configuration: t.target.configuration,
+            });
+        }
+        if (hashedTasks.length > 0) {
+            taskDetails.recordTaskDetails(hashedTasks);
+        }
+    }
+    performance.mark('hashMultipleTasks:end');
+    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
+}

package/dist/src/hasher/native-task-hasher-impl.d.ts

@@ -0,0 +1,18 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { ExternalObject, FileData, HasherOptions, HashPlanner, ProjectGraph as NativeProjectGraph, NxWorkspaceFilesExternals, TaskHasher } from '../native';
+import { PartialHash, TaskHasherImpl } from './task-hasher';
+export declare class NativeTaskHasherImpl implements TaskHasherImpl {
+    hasher: TaskHasher;
+    planner: HashPlanner;
+    projectGraphRef: ExternalObject<NativeProjectGraph>;
+    allWorkspaceFilesRef: ExternalObject<FileData[]>;
+    projectFileMapRef: ExternalObject<Record<string, FileData[]>>;
+    options: HasherOptions | undefined;
+    constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
+        selectivelyHashTsConfig: boolean;
+    });
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
+}