nx 17.0.3 → 17.0.5

package/src/tasks-runner/pseudo-terminal.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = exports.getPseudoTerminal = void 0;
+const native_1 = require("../native");
+const pseudo_ipc_1 = require("./pseudo-ipc");
+const socket_utils_1 = require("../daemon/socket-utils");
+const os = require("os");
+let pseudoTerminal;
+function getPseudoTerminal(skipSupportCheck = false) {
+    if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
+        throw new Error('Pseudo terminal is not supported on this platform.');
+    }
+    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
+    return pseudoTerminal;
+}
+exports.getPseudoTerminal = getPseudoTerminal;
+class PseudoTerminal {
+    static isSupported() {
+        return process.stdout.isTTY && supportedPtyPlatform();
+    }
+    constructor(rustPseudoTerminal) {
+        this.rustPseudoTerminal = rustPseudoTerminal;
+        this.pseudoIPCPath = (0, socket_utils_1.FORKED_PROCESS_OS_SOCKET_PATH)(process.pid.toString());
+        this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
+        this.initialized = false;
+        this.setupProcessListeners();
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        await this.pseudoIPC.init();
+        this.initialized = true;
+    }
+    runCommand(command, { cwd, jsEnv, quiet, } = {}) {
+        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet));
+    }
+    async fork(id, script, { cwd, jsEnv, quiet, }) {
+        if (!this.initialized) {
+            throw new Error('Call init() before forking processes');
+        }
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, quiet), id, this.pseudoIPC);
+        await this.pseudoIPC.waitForChildReady(id);
+        return cp;
+    }
+    sendMessageToChildren(message) {
+        this.pseudoIPC.sendMessageToChildren(message);
+    }
+    onMessageFromChildren(callback) {
+        this.pseudoIPC.onMessageFromChildren(callback);
+    }
+    setupProcessListeners() {
+        const shutdown = () => {
+            this.shutdownPseudoIPC();
+        };
+        process.on('SIGINT', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('SIGTERM', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('SIGHUP', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('exit', () => {
+            this.shutdownPseudoIPC();
+        });
+    }
+    shutdownPseudoIPC() {
+        if (this.initialized) {
+            this.pseudoIPC.close();
+        }
+    }
+}
+exports.PseudoTerminal = PseudoTerminal;
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = messageToCode(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
+        });
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    onOutput(callback) {
+        this.childProcess.onOutput(callback);
+    }
+    kill() {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
+                this.isAlive = false;
+            }
+        }
+    }
+}
+exports.PseudoTtyProcess = PseudoTtyProcess;
+class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    constructor(_childProcess, id, pseudoIpc) {
+        super(_childProcess);
+        this.id = id;
+        this.pseudoIpc = pseudoIpc;
+    }
+    send(message) {
+        this.pseudoIpc.sendMessageToChild(this.id, message);
+    }
+}
+exports.PseudoTtyProcessWithSend = PseudoTtyProcessWithSend;
+function messageToCode(message) {
+    if (message.startsWith('Terminated by ')) {
+        switch (message.replace('Terminated by ', '').trim()) {
+            case 'Termination':
+                return 143;
+            case 'Interrupt':
+                return 130;
+            default:
+                return 128;
+        }
+    }
+    else if (message.startsWith('Exited with code ')) {
+        return parseInt(message.replace('Exited with code ', '').trim());
+    }
+    else if (message === 'Success') {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+function supportedPtyPlatform() {
+    if (process.platform !== 'win32') {
+        return true;
+    }
+    let windowsVersion = os.release().split('.');
+    let windowsBuild = windowsVersion[2];
+    if (!windowsBuild) {
+        return false;
+    }
+    // Mininum supported Windows version:
+    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
+    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
+    if (+windowsBuild < 17763) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}

package/src/tasks-runner/run-command.d.ts

@@ -20,7 +20,7 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     nxArgs: NxArgs;
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
-}): Promise<0 | 1>;
+}): Promise<1 | 0>;
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;

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

@@ -17,12 +17,10 @@ const dynamic_run_one_terminal_output_life_cycle_1 = require("./life-cycles/dyna
 const create_task_graph_1 = require("./create-task-graph");
 const task_graph_utils_1 = require("./task-graph-utils");
 const params_1 = require("../utils/params");
-const task_hasher_1 = require("../hasher/task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
 const client_1 = require("../daemon/client/client");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
-const build_project_graph_1 = require("../project-graph/build-project-graph");
-const perf_hooks_1 = require("perf_hooks");
+const create_task_hasher_1 = require("../hasher/create-task-hasher");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -121,21 +119,11 @@ function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
 async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }) {
     setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles);
     const { tasksRunner, runnerOptions } = getRunner(nxArgs, nxJson);
-    let hasher;
-    if (client_1.daemonClient.enabled()) {
-        hasher = new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
-    }
-    else {
-        const { fileMap, allWorkspaceFiles } = (0, build_project_graph_1.getFileMap)();
-        hasher = new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, runnerOptions);
-    }
+    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
-    perf_hooks_1.performance.mark('hashing:start');
     await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
-    perf_hooks_1.performance.mark('hashing:end');
-    perf_hooks_1.performance.measure('hashing', 'hashing:start', 'hashing:end');
     const promiseOrObservable = tasksRunner(tasks, {
         ...runnerOptions,
         lifeCycle: new life_cycle_1.CompositeLifeCycle(constructLifeCycles(lifeCycle)),
@@ -152,7 +140,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                         title: `TaskGraph is now required as an argument to hashTask`,
                         bodyLines: [
                             `The TaskGraph object can be retrieved from the context`,
-                            'This will result in an error in Nx 18',
+                            'This will result in an error in Nx 19',
                         ],
                     });
                     taskGraph_ = taskGraph;
@@ -162,7 +150,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                         title: `The environment variables are now required as an argument to hashTask`,
                         bodyLines: [
                             `Please pass the environment variables used when running the task`,
-                            'This will result in an error in Nx 18',
+                            'This will result in an error in Nx 19',
                         ],
                     });
                     env = process.env;
@@ -175,7 +163,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                         title: `TaskGraph is now required as an argument to hashTasks`,
                         bodyLines: [
                             `The TaskGraph object can be retrieved from the context`,
-                            'This will result in an error in Nx 18',
+                            'This will result in an error in Nx 19',
                         ],
                     });
                     taskGraph_ = taskGraph;
@@ -185,7 +173,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
                         title: `The environment variables are now required as an argument to hashTasks`,
                         bodyLines: [
                             `Please pass the environment variables used when running the tasks`,
-                            'This will result in an error in Nx 18',
+                            'This will result in an error in Nx 19',
                         ],
                     });
                     env = process.env;
@@ -318,7 +306,9 @@ function getTasksRunnerPath(runner, nxJson) {
     // No tasksRunnerOptions for given --runner
     nxJson.nxCloudAccessToken ||
         // No runner prop in tasks runner options, check if access token is set.
-        nxJson.tasksRunnerOptions?.[runner]?.options?.accessToken;
+        nxJson.tasksRunnerOptions?.[runner]?.options?.accessToken ||
+        // Cloud access token specified in env var.
+        process.env.NX_CLOUD_ACCESS_TOKEN;
     return isCloudRunner ? 'nx-cloud' : require.resolve('./default-tasks-runner');
 }
 function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
@@ -332,6 +322,10 @@ function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
         ...nxJson.tasksRunnerOptions?.[runner]?.options,
         ...nxArgs,
     };
+    // NOTE: we don't pull from env here because the cloud package
+    // supports it within nx-cloud's implementation. We could
+    // normalize it here, and that may make more sense, but
+    // leaving it as is for now.
     if (nxJson.nxCloudAccessToken && isCloudDefault) {
         result.accessToken ??= nxJson.nxCloudAccessToken;
     }

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

@@ -35,8 +35,7 @@ function getEnvVariablesForTask(task, taskSpecificEnv, forceColor, skipNxCache,
         delete res.NX_STREAM_OUTPUT;
         delete res.NX_PREFIX_OUTPUT;
     }
-    delete res.NX_BASE;
-    delete res.NX_HEAD;
+    // we don't reset NX_BASE or NX_HEAD because those are set by the user and should be preserved
     delete res.NX_SET_CLI;
     return res;
 }

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

@@ -1,3 +1,7 @@
-import { TaskGraph } from '../config/task-graph';
-export declare function findCycle(taskGraph: TaskGraph): string[] | null;
-export declare function makeAcyclic(taskGraph: TaskGraph): void;
+export declare function findCycle(taskGraph: {
+    dependencies: Record<string, string[]>;
+}): string[] | null;
+export declare function makeAcyclic(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}): void;

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

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAcyclic = exports.findCycle = void 0;
-function _findCycle(taskGraph, taskId, visited, path) {
-    if (visited[taskId])
+function _findCycle(graph, id, visited, path) {
+    if (visited[id])
         return null;
-    visited[taskId] = true;
-    for (const d of taskGraph.dependencies[taskId]) {
+    visited[id] = true;
+    for (const d of graph.dependencies[id]) {
         if (path.includes(d))
             return [...path, d];
-        const cycle = _findCycle(taskGraph, d, visited, [...path, d]);
+        const cycle = _findCycle(graph, d, visited, [...path, d]);
         if (cycle)
             return cycle;
     }
@@ -27,29 +27,29 @@ function findCycle(taskGraph) {
     return null;
 }
 exports.findCycle = findCycle;
-function _makeAcyclic(taskGraph, taskId, visited, path) {
-    if (visited[taskId])
+function _makeAcyclic(graph, id, visited, path) {
+    if (visited[id])
         return;
-    visited[taskId] = true;
-    const deps = taskGraph.dependencies[taskId];
+    visited[id] = true;
+    const deps = graph.dependencies[id];
     for (const d of [...deps]) {
         if (path.includes(d)) {
             deps.splice(deps.indexOf(d), 1);
         }
         else {
-            _makeAcyclic(taskGraph, d, visited, [...path, d]);
+            _makeAcyclic(graph, d, visited, [...path, d]);
         }
     }
     return null;
 }
-function makeAcyclic(taskGraph) {
+function makeAcyclic(graph) {
     const visited = {};
-    for (const t of Object.keys(taskGraph.dependencies)) {
+    for (const t of Object.keys(graph.dependencies)) {
         visited[t] = false;
     }
-    for (const t of Object.keys(taskGraph.dependencies)) {
-        _makeAcyclic(taskGraph, t, visited, [t]);
+    for (const t of Object.keys(graph.dependencies)) {
+        _makeAcyclic(graph, t, visited, [t]);
     }
-    taskGraph.roots = Object.keys(taskGraph.dependencies).filter((t) => taskGraph.dependencies[t].length === 0);
+    graph.roots = Object.keys(graph.dependencies).filter((t) => graph.dependencies[t].length === 0);
 }
 exports.makeAcyclic = makeAcyclic;

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

@@ -3,12 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskOrchestrator = void 0;
 const events_1 = require("events");
 const perf_hooks_1 = require("perf_hooks");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
 const forked_process_task_runner_1 = require("./forked-process-task-runner");
 const cache_1 = require("./cache");
 const utils_1 = require("./utils");
 const tasks_schedule_1 = require("./tasks-schedule");
 const hash_task_1 = require("../hasher/hash-task");
 const task_env_1 = require("./task-env");
+const workspace_root_1 = require("../utils/workspace-root");
+const output_1 = require("../utils/output");
+const params_1 = require("../utils/params");
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon) {
@@ -33,6 +39,8 @@ class TaskOrchestrator {
         this.bailed = false;
     }
     async run() {
+        // Init the ForkedProcessTaskRunner
+        await this.forkedProcessTaskRunner.init();
         // initial scheduling
         await this.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
@@ -193,7 +201,7 @@ class TaskOrchestrator {
         // obtain metadata
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
         const streamOutput = (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
-        const env = pipeOutput
+        let env = pipeOutput
             ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, process.env.FORCE_COLOR === undefined
                 ? 'true'
                 : process.env.FORCE_COLOR, this.options.skipNxCache, this.options.captureStderr, null, null)
@@ -201,29 +209,74 @@ class TaskOrchestrator {
         let results = doNotSkipCache ? await this.applyCachedResults([task]) : [];
         // the task wasn't cached
         if (results.length === 0) {
-            // cache prep
-            const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-            results.push({
-                task,
-                status: code === 0 ? 'success' : 'failure',
-                terminalOutput,
-            });
+            const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+            const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
+            if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
+                targetConfiguration.executor === 'nx:run-commands' &&
+                !shouldPrefix) {
+                const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+                const isRunOne = this.initiatingProject != null;
+                const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
+                if (combinedOptions.env) {
+                    env = {
+                        ...env,
+                        ...combinedOptions.env,
+                    };
+                }
+                if (streamOutput) {
+                    const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                    output_1.output.logCommand(args.join(' '));
+                }
+                const { success, terminalOutput } = await (0, run_commands_impl_1.default)({
+                    ...combinedOptions,
+                    env,
+                    usePty: isRunOne && !this.tasksSchedule.hasTasks(),
+                    streamOutput,
+                }, {
+                    root: workspace_root_1.workspaceRoot, // only root is needed in runCommandsImpl
+                });
+                const status = success ? 'success' : 'failure';
+                if (!streamOutput) {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput);
+                }
+                (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                results.push({
+                    task,
+                    status,
+                    terminalOutput,
+                });
+            }
+            else {
+                // cache prep
+                const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+                results.push({
+                    task,
+                    status: code === 0 ? 'success' : 'failure',
+                    terminalOutput,
+                });
+            }
         }
         await this.postRunSteps([task], results, doNotSkipCache, { groupId });
     }
     async runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput) {
         try {
+            const usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false';
+            // Disable the pseudo terminal if this is a run-many
+            const disablePseudoTerminal = !this.initiatingProject;
             // execution
-            const { code, terminalOutput } = pipeOutput
-                ? await this.forkedProcessTaskRunner.forkProcessPipeOutputCapture(task, {
+            const { code, terminalOutput } = usePtyFork
+                ? await this.forkedProcessTaskRunner.forkProcess(task, {
                     temporaryOutputPath,
                     streamOutput,
+                    pipeOutput,
                     taskGraph: this.taskGraph,
                     env,
+                    disablePseudoTerminal,
                 })
-                : await this.forkedProcessTaskRunner.forkProcessDirectOutputCapture(task, {
+                : await this.forkedProcessTaskRunner.forkProcessLegacy(task, {
                     temporaryOutputPath,
                     streamOutput,
+                    pipeOutput,
                     taskGraph: this.taskGraph,
                     env,
                 });
@@ -327,7 +380,10 @@ class TaskOrchestrator {
     // region utils
     async pipeOutputCapture(task) {
         try {
-            const { schema } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+            if (process.env.NX_NATIVE_COMMAND_RUNNER !== 'false') {
+                return true;
+            }
+            const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
             return (schema.outputCapture === 'pipe' ||
                 process.env.NX_STREAM_OUTPUT === 'true');
         }

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

@@ -89,7 +89,7 @@ class TasksSchedule {
         const batchMap = {};
         for (const root of this.notScheduledTaskGraph.roots) {
             const rootTask = this.notScheduledTaskGraph.tasks[root];
-            const executorName = await (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
+            const executorName = (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
             await this.processTaskForBatches(batchMap, rootTask, executorName, true);
         }
         for (const [executorName, taskGraph] of Object.entries(batchMap)) {
@@ -105,8 +105,8 @@ class TasksSchedule {
         if (!this.canBatchTaskBeScheduled(task.id, batches[rootExecutorName])) {
             return;
         }
-        const { batchImplementationFactory } = await (0, utils_1.getExecutorForTask)(task, this.projectGraph);
-        const executorName = await (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
+        const { batchImplementationFactory } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+        const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
         if (rootExecutorName !== executorName) {
             return;
         }

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

@@ -1,7 +1,7 @@
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { CustomHasher } from '../config/misc-interfaces';
+import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 export declare function getCommandAsString(execCommand: string, task: Task): string;
 export declare function getDependencyConfigs({ project, target }: {
     project: string;
@@ -18,18 +18,27 @@ declare class InvalidOutputsError extends Error {
 export declare function validateOutputs(outputs: string[]): void;
 export declare function transformLegacyOutputs(projectRoot: string, error: InvalidOutputsError): string[];
 /**
- * @deprecated Pass the target and overrides instead. This will be removed in v18.
+ * @deprecated Pass the target and overrides instead. This will be removed in v19.
  */
 export declare function getOutputsForTargetAndConfiguration(task: Task, node: ProjectGraphProjectNode): string[];
 export declare function getOutputsForTargetAndConfiguration(target: Task['target'] | Task, overrides: Task['overrides'] | ProjectGraphProjectNode, node: ProjectGraphProjectNode): string[];
 export declare function interpolate(template: string, data: any): string;
-export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): Promise<string>;
-export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): Promise<import("../config/misc-interfaces").ExecutorConfig & {
+export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
+export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): ExecutorConfig & {
     isNgCompat: boolean;
     isNxExecutor: boolean;
-}>;
-export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): Promise<CustomHasher> | null;
+};
+export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
+export declare function removeIdsFromGraph<T>(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}, ids: string[], mapWithIds: Record<string, T>): {
+    mapWithIds: Record<string, T>;
+    roots: string[];
+    dependencies: Record<string, string[]>;
+};
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;
 export declare function getPrintableCommandArgsForTask(task: Task): string[];

package/src/tasks-runner/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
+exports.unparse = exports.isCacheableTask = exports.shouldStreamOutput = exports.getSerializedArgsForTask = exports.getPrintableCommandArgsForTask = exports.getCliPath = exports.calculateReverseDeps = exports.removeIdsFromGraph = exports.removeTasksFromTaskGraph = exports.getCustomHasher = exports.getExecutorForTask = exports.getExecutorNameForTask = exports.getTargetConfigurationForTask = exports.interpolate = exports.getOutputsForTargetAndConfiguration = exports.transformLegacyOutputs = exports.validateOutputs = exports.getOutputs = exports.expandDependencyConfigSyntaxSugar = exports.getDependencyConfigs = exports.getCommandAsString = void 0;
 const output_1 = require("../utils/output");
 const path_1 = require("path");
 const workspace_root_1 = require("../utils/workspace-root");
@@ -9,6 +9,7 @@ const fileutils_1 = require("../utils/fileutils");
 const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
 const split_target_1 = require("../utils/split-target");
 const executor_utils_1 = require("../command-line/run/executor-utils");
+const project_graph_1 = require("../project-graph/project-graph");
 function getCommandAsString(execCommand, task) {
     const args = getPrintableCommandArgsForTask(task);
     return [execCommand, 'nx', ...args].join(' ').trim();
@@ -127,7 +128,7 @@ function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode,
             return interpolate(output, {
                 projectRoot: node.data.root,
                 projectName: node.name,
-                project: { ...node.data, name: node.name },
+                project: { ...node.data, name: node.name }, // this is legacy
                 options,
             });
         })
@@ -176,39 +177,52 @@ function interpolate(template, data) {
     });
 }
 exports.interpolate = interpolate;
-async function getExecutorNameForTask(task, projectGraph) {
+function getTargetConfigurationForTask(task, projectGraph) {
     const project = projectGraph.nodes[task.target.project].data;
-    return project.targets[task.target.target].executor;
+    return project.targets[task.target.target];
+}
+exports.getTargetConfigurationForTask = getTargetConfigurationForTask;
+function getExecutorNameForTask(task, projectGraph) {
+    return getTargetConfigurationForTask(task, projectGraph)?.executor;
 }
 exports.getExecutorNameForTask = getExecutorNameForTask;
-async function getExecutorForTask(task, projectGraph) {
-    const executor = await getExecutorNameForTask(task, projectGraph);
+function getExecutorForTask(task, projectGraph) {
+    const executor = getExecutorNameForTask(task, projectGraph);
     const [nodeModule, executorName] = executor.split(':');
-    return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot);
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
 }
 exports.getExecutorForTask = getExecutorForTask;
-async function getCustomHasher(task, projectGraph) {
-    const factory = (await getExecutorForTask(task, projectGraph)).hasherFactory;
+function getCustomHasher(task, projectGraph) {
+    const factory = getExecutorForTask(task, projectGraph).hasherFactory;
     return factory ? factory() : null;
 }
 exports.getCustomHasher = getCustomHasher;
 function removeTasksFromTaskGraph(graph, ids) {
-    const tasks = {};
+    const newGraph = removeIdsFromGraph(graph, ids, graph.tasks);
+    return {
+        dependencies: newGraph.dependencies,
+        roots: newGraph.roots,
+        tasks: newGraph.mapWithIds,
+    };
+}
+exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
+function removeIdsFromGraph(graph, ids, mapWithIds) {
+    const filteredMapWithIds = {};
     const dependencies = {};
     const removedSet = new Set(ids);
-    for (let taskId of Object.keys(graph.tasks)) {
-        if (!removedSet.has(taskId)) {
-            tasks[taskId] = graph.tasks[taskId];
-            dependencies[taskId] = graph.dependencies[taskId].filter((depTaskId) => !removedSet.has(depTaskId));
+    for (let id of Object.keys(mapWithIds)) {
+        if (!removedSet.has(id)) {
+            filteredMapWithIds[id] = mapWithIds[id];
+            dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
         }
     }
     return {
-        tasks,
+        mapWithIds: filteredMapWithIds,
         dependencies: dependencies,
         roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
     };
 }
-exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
+exports.removeIdsFromGraph = removeIdsFromGraph;
 function calculateReverseDeps(taskGraph) {
     const reverseTaskDeps = {};
     Object.keys(taskGraph.tasks).forEach((t) => {