nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/tasks-runner/running-tasks/batch-process.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BatchProcess = void 0;
-const tslib_1 = require("tslib");
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const native_1 = require("../../native");
 const exit_codes_1 = require("../../utils/exit-codes");
 const batch_messages_1 = require("../batch/batch-messages");
 class BatchProcess {
@@ -103,10 +102,9 @@ class BatchProcess {
     }
     kill(signal) {
         if (this.childProcess?.pid) {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, () => {
-                // Ignore errors - process may have already exited
-            });
+            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
         }
+        return Promise.resolve();
     }
 }
 exports.BatchProcess = BatchProcess;

package/dist/src/tasks-runner/running-tasks/node-child-process.d.ts

@@ -18,7 +18,7 @@ export declare class NodeChildProcessWithNonDirectOutput implements RunningTask
         terminalOutput: string;
     }>;
     send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals): void;
+    kill(signal?: NodeJS.Signals): Promise<void>;
 }
 export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     private childProcess;
@@ -36,5 +36,5 @@ export declare class NodeChildProcessWithDirectOutput implements RunningTask {
     }>;
     waitForExit(): Promise<void>;
     getTerminalOutput(): string;
-    kill(signal?: NodeJS.Signals): void;
+    kill(signal?: NodeJS.Signals): Promise<void>;
 }

package/dist/src/tasks-runner/running-tasks/node-child-process.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 const pc = tslib_1.__importStar(require("picocolors"));
 const fs_1 = require("fs");
 const stream_1 = require("stream");
-const tree_kill_1 = tslib_1.__importDefault(require("tree-kill"));
+const native_1 = require("../../native");
 const exit_codes_1 = require("../../utils/exit-codes");
 const output_prefix_1 = require("./output-prefix");
 class NodeChildProcessWithNonDirectOutput {
@@ -97,10 +97,9 @@ class NodeChildProcessWithNonDirectOutput {
     }
     kill(signal) {
         if (this.childProcess?.pid) {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, () => {
-                // Ignore errors - process may have already exited
-            });
+            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
         }
+        return Promise.resolve();
     }
 }
 exports.NodeChildProcessWithNonDirectOutput = NodeChildProcessWithNonDirectOutput;
@@ -168,10 +167,9 @@ class NodeChildProcessWithDirectOutput {
     }
     kill(signal) {
         if (this.childProcess?.pid) {
-            (0, tree_kill_1.default)(this.childProcess.pid, signal, () => {
-                // Ignore errors - process may have already exited
-            });
+            return (0, native_1.killProcessTreeGraceful)(this.childProcess.pid, signal);
         }
+        return Promise.resolve();
     }
 }
 exports.NodeChildProcessWithDirectOutput = NodeChildProcessWithDirectOutput;

package/dist/src/tasks-runner/task-env.d.ts

@@ -1,5 +1,5 @@
-import { Task } from '../config/task-graph';
 import { ProjectGraph } from '../config/project-graph';
+import { Task } from '../config/task-graph';
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task, graph: ProjectGraph): NodeJS.ProcessEnv;
 export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;

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

@@ -8,8 +8,8 @@ exports.unloadDotEnvFile = unloadDotEnvFile;
 exports.getEnvFilesForTask = getEnvFilesForTask;
 const dotenv_1 = require("dotenv");
 const dotenv_expand_1 = require("dotenv-expand");
-const workspace_root_1 = require("../utils/workspace-root");
 const node_path_1 = require("node:path");
+const workspace_root_1 = require("../utils/workspace-root");
 const task_env_paths_1 = require("./task-env-paths");
 function getEnvVariablesForBatchProcess(skipNxCache, captureStderr) {
     return {
@@ -90,11 +90,16 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
     if (task.target.target === 'test') {
         env.NX_TERMINAL_CAPTURE_STDERR = 'true';
     }
+    // Pass the root Nx process PID to nested processes for DB-based loop detection.
+    // The root PID is used as a key in the task_invocations table to track which tasks
+    // have been invoked across nested Nx processes.
     return {
         ...getNxEnvVariablesForForkedProcess(forceColor, skipNxCache, captureStderr, outputPath, streamOutput),
         ...env,
         // Ensure the TUI does not get spawned within the TUI if ever tasks invoke Nx again
         NX_TUI: 'false',
+        // tracks the root PID for child nx tasks, used to verify nx is infinitely recursing through the same tasks
+        NX_INVOCATION_ROOT_PID: process.env.NX_INVOCATION_ROOT_PID ?? String(process.pid),
     };
 }
 /**

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

@@ -7,9 +7,9 @@ import { NxArgs } from '../utils/command-line-utils';
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { TaskResult } from './life-cycle';
 import { RunningTask } from './running-tasks/running-task';
+import { SharedRunningTask } from './running-tasks/shared-running-task';
 import { TaskStatus } from './tasks-runner';
 import { Batch } from './tasks-schedule';
-import { SharedRunningTask } from './running-tasks/shared-running-task';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
@@ -28,6 +28,8 @@ export declare class TaskOrchestrator {
     private readonly projects;
     private forkedProcessTaskRunner;
     private runningTasksService;
+    private taskInvocationTracker;
+    private registeredInvocations;
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
@@ -67,6 +69,13 @@ export declare class TaskOrchestrator {
     private executeContinuousTaskLoop;
     private processTask;
     processAllScheduledTasks(): void;
+    /**
+     * Registers a task invocation and checks for loops across nested Nx processes.
+     * Uses the task_invocations DB table keyed by root PID. registerTask() throws
+     * on unique constraint violation when a parent Nx process already registered
+     * this task — indicating an infinite loop.
+     */
+    private detectTaskInvocationLoop;
     private applyCachedResults;
     /**
      * Batch cache lookup + filter to successful entries. Handles both
@@ -166,6 +175,7 @@ export declare class TaskOrchestrator {
     private shouldCopyOutputsFromCacheBatch;
     private recordOutputsHashBatch;
     private handleContinuousTaskExit;
+    private isContinuousTaskNeeded;
     private completeContinuousTask;
     private cleanup;
     private performCleanup;

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

@@ -5,9 +5,9 @@ exports.getThreadPoolSize = getThreadPoolSize;
 const tslib_1 = require("tslib");
 const events_1 = require("events");
 const fs_1 = require("fs");
-const pc = tslib_1.__importStar(require("picocolors"));
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
+const pc = tslib_1.__importStar(require("picocolors"));
 const project_graph_1 = require("../project-graph/project-graph");
 const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
 const hash_task_1 = require("../hasher/hash-task");
@@ -15,20 +15,28 @@ const task_graph_utils_1 = require("./task-graph-utils");
 const task_hasher_1 = require("../hasher/task-hasher");
 const native_1 = require("../native");
 const db_connection_1 = require("../utils/db-connection");
+const exit_codes_1 = require("../utils/exit-codes");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
 const workspace_root_1 = require("../utils/workspace-root");
-const exit_codes_1 = require("../utils/exit-codes");
 const cache_1 = require("./cache");
 const forked_process_task_runner_1 = require("./forked-process-task-runner");
 const is_tui_enabled_1 = require("./is-tui-enabled");
 const pseudo_terminal_1 = require("./pseudo-terminal");
-const output_prefix_1 = require("./running-tasks/output-prefix");
 const noop_child_process_1 = require("./running-tasks/noop-child-process");
+const output_prefix_1 = require("./running-tasks/output-prefix");
+const shared_running_task_1 = require("./running-tasks/shared-running-task");
 const task_env_1 = require("./task-env");
 const tasks_schedule_1 = require("./tasks-schedule");
 const utils_1 = require("./utils");
-const shared_running_task_1 = require("./running-tasks/shared-running-task");
+/**
+ * Resolve a batch executor's per-task result to a TaskStatus. Prefers an
+ * explicit `status` from the executor; falls back to the `success` boolean
+ * for executors that pre-date the `status` field.
+ */
+function resolveBatchTaskStatus(result) {
+    return result.status ?? (result.success ? 'success' : 'failure');
+}
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
@@ -53,6 +61,13 @@ class TaskOrchestrator {
         this.runningTasksService = !native_1.IS_WASM
             ? new native_1.RunningTasksService((0, db_connection_1.getLocalDbConnection)())
             : null;
+        this.taskInvocationTracker = !native_1.IS_WASM
+            ? new native_1.TaskInvocationTracker((0, db_connection_1.getLocalDbConnection)(), Number(process.env.NX_INVOCATION_ROOT_PID ?? process.pid))
+            : null;
+        // Tracks tasks registered by THIS process so that recursive code paths
+        // (e.g. applyFromCacheOrRunBatch looping on incomplete batches) don't
+        // re-register and trip the DB uniqueness constraint.
+        this.registeredInvocations = new Set();
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.projects, this.taskGraph, this.options);
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
@@ -81,6 +96,7 @@ class TaskOrchestrator {
     }
     async init() {
         this.setupSignalHandlers();
+        this.taskInvocationTracker?.cleanupStale();
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
         await Promise.all([
             this.forkedProcessTaskRunner.init(),
@@ -255,10 +271,46 @@ class TaskOrchestrator {
             }
         }
     }
+    /**
+     * Registers a task invocation and checks for loops across nested Nx processes.
+     * Uses the task_invocations DB table keyed by root PID. registerTask() throws
+     * on unique constraint violation when a parent Nx process already registered
+     * this task — indicating an infinite loop.
+     */
+    detectTaskInvocationLoop(task) {
+        if (!this.taskInvocationTracker)
+            return;
+        if (this.registeredInvocations.has(task.id))
+            return;
+        try {
+            this.taskInvocationTracker.registerTask(process.pid, task.id);
+            this.registeredInvocations.add(task.id);
+        }
+        catch {
+            // Unique constraint violation — task already invoked by an ancestor Nx process
+            const chain = this.taskInvocationTracker.getInvocationChain();
+            const chainDisplay = chain.map((r) => r.taskId).join(' -> ');
+            output_1.output.error({
+                title: 'Recursive task invocation detected',
+                bodyLines: [
+                    `Nx detected a recursive loop of task invocations:`,
+                    ``,
+                    `  ${chainDisplay} -> ${task.id}`,
+                    ``,
+                    `Task "${task.id}" was already invoked by a parent Nx process in this chain.`,
+                    `This typically happens when a task's command (e.g., "nx ${task.target.target} ${task.target.project}")`,
+                    `triggers a chain of tasks that eventually re-invokes itself.`,
+                    ``,
+                    `To fix this, review the command configuration for the tasks in the chain above.`,
+                ],
+            });
+            process.exit(1);
+        }
+    }
     // endregion Processing Scheduled Tasks
     // region Applying Cache
     async applyCachedResults(tasks) {
-        const cacheableTasks = tasks.filter((t) => (0, utils_1.isCacheableTask)(t, this.options));
+        const cacheableTasks = tasks.filter((t) => t.cache);
         if (cacheableTasks.length === 0)
             return [];
         const cacheHits = await this.fetchCacheHits(cacheableTasks);
@@ -340,9 +392,7 @@ class TaskOrchestrator {
         const candidates = [];
         for (const id of scheduledTasks) {
             const task = this.taskGraph.tasks[id];
-            if (task.hash &&
-                !task.continuous &&
-                (0, utils_1.isCacheableTask)(task, this.options)) {
+            if (task.hash && !task.continuous && task.cache) {
                 candidates.push(task);
             }
         }
@@ -448,6 +498,9 @@ class TaskOrchestrator {
         let batchResults = [];
         if (taskIdsToSkip.length < tasks.length) {
             const runGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, taskIdsToSkip);
+            for (const task of Object.values(runGraph.tasks)) {
+                this.detectTaskInvocationLoop(task);
+            }
             batchResults = await this.runBatch({
                 id: batch.id,
                 executorName: batch.executorName,
@@ -498,11 +551,18 @@ class TaskOrchestrator {
             // Heavy operations (caching, scheduling, complete) happen at batch-end in postRunSteps
             batchProcess.onTaskResults((taskId, result) => {
                 const task = this.taskGraph.tasks[taskId];
-                const status = result.success ? 'success' : 'failure';
-                this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
+                const status = resolveBatchTaskStatus(result);
+                // Append before print so printTaskTerminalOutput finds the PTY already
+                // populated and no-ops; reversing the order writes terminalOutput twice.
                 if (result.terminalOutput) {
                     this.options.lifeCycle.appendTaskOutput(taskId, result.terminalOutput, false);
                 }
+                // Skipped tasks didn't run, so they have no terminal output and don't
+                // need a per-task PTY — calling printTaskTerminalOutput would otherwise
+                // allocate one just to write a cursor-hide escape.
+                if (status !== 'skipped') {
+                    this.options.lifeCycle.printTaskTerminalOutput(task, status, result.terminalOutput ?? '');
+                }
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
                 if (result.startTime && result.endTime) {
@@ -516,10 +576,11 @@ class TaskOrchestrator {
                 const task = this.taskGraph.tasks[taskId];
                 task.startTime = result.startTime;
                 task.endTime = result.endTime;
+                const status = resolveBatchTaskStatus(result);
                 return {
-                    code: result.success ? 0 : 1,
+                    code: status === 'success' ? 0 : 1,
                     task,
-                    status: (result.success ? 'success' : 'failure'),
+                    status,
                     terminalOutput: result.terminalOutput,
                 };
             });
@@ -563,7 +624,7 @@ class TaskOrchestrator {
     async resolveCachedTasks(doNotSkipCache, tasks, groupId) {
         if (!doNotSkipCache || tasks.length === 0)
             return [];
-        const cacheableTasks = tasks.filter((t) => (0, utils_1.isCacheableTask)(t, this.options));
+        const cacheableTasks = tasks.filter((t) => t.cache);
         if (cacheableTasks.length === 0)
             return [];
         // Wait for any queued processTask promises to settle so task.hash is
@@ -641,6 +702,7 @@ class TaskOrchestrator {
         let resolveDiscreteExit;
         const discreteExitHandled = new Promise((r) => (resolveDiscreteExit = r));
         this.discreteTaskExitHandled.set(task.id, discreteExitHandled);
+        this.detectTaskInvocationLoop(task);
         const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
         this.runningDiscreteTasks.set(task.id, {
             runningTask: childProcess,
@@ -850,6 +912,7 @@ class TaskOrchestrator {
                 ? 'true'
                 : process.env.FORCE_COLOR, this.options.skipNxCache, this.options.captureStderr, null, null)
             : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
+        this.detectTaskInvocationLoop(task);
         const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
         this.runningTasksService?.addRunningTask(task.id);
         this.runningContinuousTasks.set(task.id, {
@@ -974,6 +1037,8 @@ class TaskOrchestrator {
             if (this.completedTasks.has(task.id))
                 continue;
             this.completedTasks.set(task.id, status);
+            this.taskInvocationTracker?.unregisterTask(task.id);
+            this.registeredInvocations.delete(task.id);
             if (this.tuiEnabled) {
                 this.options.lifeCycle.setTaskStatus(task.id, displayStatus ?? (0, native_1.parseTaskStatus)(status));
             }
@@ -1028,7 +1093,7 @@ class TaskOrchestrator {
         }
     }
     shouldCacheTaskResult(task, code) {
-        return ((0, utils_1.isCacheableTask)(task, this.options) &&
+        return (task.cache &&
             (process.env.NX_CACHE_FAILURES == 'true' ? true : code === 0));
     }
     closeGroup() {
@@ -1076,11 +1141,21 @@ class TaskOrchestrator {
             const reason = stoppingReason === 'fulfilled' ? 'fulfilled' : 'interrupted';
             await this.completeContinuousTask(task, groupId, ownsRunningTasksService, reason);
         }
+        else if (!this.isContinuousTaskNeeded(task.id)) {
+            // No remaining tasks depend on this — the task was about to be
+            // killed by cleanUpUnneededContinuousTasks anyway.
+            await this.completeContinuousTask(task, groupId, ownsRunningTasksService, 'fulfilled');
+        }
         else {
             console.error(`Task "${task.id}" is continuous but exited with code ${code}`);
             await this.completeContinuousTask(task, groupId, ownsRunningTasksService, 'crashed');
         }
     }
+    isContinuousTaskNeeded(taskId) {
+        return this.tasksSchedule
+            .getIncompleteTasks()
+            .some((t) => this.taskGraph.continuousDependencies[t.id]?.includes(taskId));
+    }
     async completeContinuousTask(task, groupId, ownsRunningTasksService, reason) {
         if (this.completedTasks.has(task.id))
             return;
@@ -1134,9 +1209,11 @@ class TaskOrchestrator {
                 continue;
             await this.completeContinuousTask(task, groupId, ownsRunningTasksService, reason);
         }
-        // Kill all processes
-        this.forkedProcessTaskRunner.cleanup();
+        // Kill all processes — await forked runner cleanup for graceful shutdown
+        const forkedCleanup = this.forkedProcessTaskRunner.cleanup();
+        const continuousTaskIds = new Set(continuousSnapshot.map(([id]) => id));
         await Promise.all([
+            forkedCleanup,
             ...continuousSnapshot.map(async ([taskId, { runningTask }]) => {
                 try {
                     await runningTask.kill();
@@ -1153,7 +1230,10 @@ class TaskOrchestrator {
                     console.error(`Unable to terminate ${taskId}\nError:`, e);
                 }
             }),
-            ...Array.from(this.runningRunCommandsTasks).map(async ([taskId, t]) => {
+            // Skip tasks already killed via continuousSnapshot to avoid duplicate signals
+            ...Array.from(this.runningRunCommandsTasks)
+                .filter(([taskId]) => !continuousTaskIds.has(taskId))
+                .map(async ([taskId, t]) => {
                 try {
                     await t.kill();
                 }
@@ -1168,19 +1248,26 @@ class TaskOrchestrator {
         await Promise.all(this.discreteTaskExitHandled.values());
     }
     setupSignalHandlers() {
-        process.once('SIGINT', () => {
+        // Use process.on (not once) so the handler stays registered and absorbs
+        // re-raised signals from signal-exit. Without this, signal-exit's handler
+        // sees no remaining listeners after our once-handler auto-removes, and
+        // re-raises the signal — killing the process before async cleanup completes.
+        // The cleanup() idempotency guard (cleanupPromise) prevents double execution.
+        const handleSignal = (signal) => {
+            if (this.stopRequested)
+                return;
             this.stopRequested = true;
             if (!this.tuiEnabled) {
                 // Synchronously remove DB entries before async cleanup to prevent
                 // new nx processes from seeing stale "Waiting for ..." messages.
-                // This replicates the cleanup that process.exit() + Rust Drop
-                // previously provided.
                 for (const [taskId, { ownsRunningTasksService }] of this
                     .runningContinuousTasks) {
                     if (ownsRunningTasksService) {
                         this.runningTasksService?.removeRunningTask(taskId);
                     }
                 }
+            }
+            if (signal === 'SIGINT' && !this.tuiEnabled) {
                 // Silence output — pnpm (and similar wrappers) may exit before nx
                 // finishes cleanup, returning the shell prompt. Any output after
                 // that point would appear after the prompt.
@@ -1197,26 +1284,13 @@ class TaskOrchestrator {
                     this.resolveStopPromise();
                 }
                 else {
-                    process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
-                }
-            });
-        });
-        process.once('SIGTERM', () => {
-            this.stopRequested = true;
-            this.cleanup().finally(() => {
-                if (this.resolveStopPromise) {
-                    this.resolveStopPromise();
-                }
-            });
-        });
-        process.once('SIGHUP', () => {
-            this.stopRequested = true;
-            this.cleanup().finally(() => {
-                if (this.resolveStopPromise) {
-                    this.resolveStopPromise();
+                    process.exit((0, exit_codes_1.signalToCode)(signal));
                 }
             });
-        });
+        };
+        process.on('SIGINT', () => handleSignal('SIGINT'));
+        process.on('SIGTERM', () => handleSignal('SIGTERM'));
+        process.on('SIGHUP', () => handleSignal('SIGHUP'));
     }
     cleanUpUnneededContinuousTasks() {
         const incompleteTasks = this.tasksSchedule.getIncompleteTasks();

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

@@ -223,9 +223,9 @@ class TasksSchedule {
         }
     }
     canBatchTaskBeScheduled(task, batchTaskGraph) {
-        // task self needs to have parallelism true
+        // task self needs to support parallelism (undefined defaults to parallel)
         // all deps have either completed or belong to the same batch
-        return (task.parallelism === true &&
+        return (task.parallelism !== false &&
             this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
     }
     canBeScheduled(taskId) {
@@ -248,7 +248,7 @@ class TasksSchedule {
         }
         else {
             // if all running tasks support parallelism, can only schedule task with parallelism
-            return this.taskGraph.tasks[taskId].parallelism === true;
+            return this.taskGraph.tasks[taskId].parallelism !== false;
         }
     }
     getEstimatedTaskTimings() {

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

@@ -2,6 +2,7 @@ import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { ProjectConfiguration, TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { LegacyDependsOnLocation } from './legacy-depends-on-warning';
 export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
     projects: string[];
 };
@@ -9,8 +10,9 @@ export declare function getDependencyConfigs({ project, target }: {
     project: string;
     target: string;
 }, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[] | undefined;
-export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
-export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph): NormalizedTargetDependencyConfig;
+export type DependsOnEntryLocation = LegacyDependsOnLocation;
+export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[], location?: DependsOnEntryLocation): NormalizedTargetDependencyConfig[];
+export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph, location?: DependsOnEntryLocation): NormalizedTargetDependencyConfig;
 export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string | TargetDependencyConfig, graph: ProjectGraph, currentProject?: string): TargetDependencyConfig;
 export declare function expandWildcardTargetConfiguration(dependencyConfig: NormalizedTargetDependencyConfig, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
 export declare function readProjectAndTargetFromTargetString(targetString: string, projects: Record<string, ProjectGraphProjectNode>, currentProject?: string): {
@@ -18,8 +20,8 @@ export declare function readProjectAndTargetFromTargetString(targetString: strin
     target: string;
 };
 export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
-export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig): Omit<TargetDependencyConfig, 'projects'> & {
-    projects: string[];
+export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig, currentProject?: string, location?: DependsOnEntryLocation): Omit<TargetDependencyConfig, 'projects'> & {
+    projects?: string[];
 };
 export declare function validateOutputs(outputs: string[]): void;
 export declare function transformLegacyOutputs(projectRoot: string, outputs: string[]): string[];
@@ -50,12 +52,9 @@ export declare function getCustomHasher(task: Task, projects: Record<string, Pro
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;
+export declare function getUnparsedOverrideArgs(task: Task): string[];
 export declare function getPrintableCommandArgsForTask(task: Task): string[];
 export declare function getSerializedArgsForTask(task: Task, isVerbose: boolean): string[];
 export declare function shouldStreamOutput(task: Task, initiatingProject: string | null): boolean;
-export declare function isCacheableTask(task: Task, options: {
-    cacheableOperations?: string[] | null;
-    cacheableTargets?: string[] | null;
-}): boolean;
 export declare function unparse(options: Object): string[];
 export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;

package/dist/src/tasks-runner/utils.js

@@ -20,10 +20,10 @@ exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
 exports.getCliPath = getCliPath;
+exports.getUnparsedOverrideArgs = getUnparsedOverrideArgs;
 exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
 exports.getSerializedArgsForTask = getSerializedArgsForTask;
 exports.shouldStreamOutput = shouldStreamOutput;
-exports.isCacheableTask = isCacheableTask;
 exports.unparse = unparse;
 exports.createTaskId = createTaskId;
 const minimatch_1 = require("minimatch");
@@ -33,6 +33,7 @@ const executor_utils_1 = require("../command-line/run/executor-utils");
 const native_1 = require("../native");
 const fileutils_1 = require("../utils/fileutils");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
+const legacy_depends_on_warning_1 = require("./legacy-depends-on-warning");
 const globs_1 = require("../utils/globs");
 const path_1 = require("../utils/path");
 const serialize_overrides_into_command_line_1 = require("../utils/serialize-overrides-into-command-line");
@@ -40,17 +41,21 @@ const split_target_1 = require("../utils/split-target");
 const workspace_root_1 = require("../utils/workspace-root");
 const is_tui_enabled_1 = require("./is-tui-enabled");
 function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
+    const legacyViolations = [];
     const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
         // This is passed into `run-command` from programmatic invocations
         extraTargetDependencies[target] ??
-        []).flatMap((config) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames));
+        []).flatMap((config, index) => normalizeDependencyConfigDefinition(config, project, projectGraph, allTargetNames, { ownerTarget: target, index, legacyViolations }));
+    if (legacyViolations.length) {
+        (0, legacy_depends_on_warning_1.flushLegacyDependsOnViolations)(project, target, legacyViolations, projectGraph.nodes[project]?.data?.root);
+    }
     return dependencyConfigs;
 }
-function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames) {
-    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph), allTargetNames);
+function normalizeDependencyConfigDefinition(definition, currentProject, graph, allTargetNames, location) {
+    return expandWildcardTargetConfiguration(normalizeDependencyConfigProjects(expandDependencyConfigSyntaxSugar(definition, graph, currentProject), currentProject, graph, location), allTargetNames);
 }
-function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph) {
-    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig);
+function normalizeDependencyConfigProjects(dependencyConfig, currentProject, graph, location) {
+    const noStringConfig = normalizeTargetDependencyWithStringProjects(dependencyConfig, currentProject, location);
     if (noStringConfig.projects) {
         dependencyConfig.projects = (0, find_matching_projects_1.findMatchingProjects)(noStringConfig.projects, graph.nodes);
     }
@@ -125,23 +130,19 @@ function readProjectAndTargetFromTargetString(targetString, projects, currentPro
 function getOutputs(p, target, overrides) {
     return getOutputsForTargetAndConfiguration(target, overrides, p[target.project]);
 }
-function normalizeTargetDependencyWithStringProjects(dependencyConfig) {
+function normalizeTargetDependencyWithStringProjects(dependencyConfig, currentProject, location) {
     if (typeof dependencyConfig.projects === 'string') {
-        /** LERNA SUPPORT START - Remove in v20 */
-        // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
-        // support for it until lerna can be updated to use the syntax.
-        //
-        // This should have been removed in v17, but the updates to lerna had not
-        // been made yet.
-        //
-        // TODO(@agentender): Remove this part in v20
+        // TODO(v24): Remove the `self` / `dependencies` magic-string shim.
+        // The v16 `update-depends-on-to-tokens` migration already rewrites
+        // these to the modern shape, and `nx repair` will re-run it on demand.
         if (dependencyConfig.projects === 'self') {
+            (0, legacy_depends_on_warning_1.warnLegacyDependsOnMagicString)(currentProject, dependencyConfig, location);
             delete dependencyConfig.projects;
         }
         else if (dependencyConfig.projects === 'dependencies') {
+            (0, legacy_depends_on_warning_1.warnLegacyDependsOnMagicString)(currentProject, dependencyConfig, location);
             dependencyConfig.dependencies = true;
             delete dependencyConfig.projects;
-            /** LERNA SUPPORT END - Remove in v20 */
         }
         else {
             dependencyConfig.projects = [dependencyConfig.projects];
@@ -206,7 +207,7 @@ function transformLegacyOutputs(projectRoot, outputs) {
 function getOutputsForTargetAndConfiguration(taskTargetOrTask, overridesOrNode, node) {
     const taskTarget = 'id' in taskTargetOrTask ? taskTargetOrTask.target : taskTargetOrTask;
     const overrides = 'id' in taskTargetOrTask ? taskTargetOrTask.overrides : overridesOrNode;
-    node = 'id' in taskTargetOrTask ? overridesOrNode : node;
+    node = ('id' in taskTargetOrTask ? overridesOrNode : node);
     const { target, configuration } = taskTarget;
     const targetConfiguration = node.data.targets[target];
     const options = {
@@ -385,8 +386,12 @@ function calculateReverseDeps(taskGraph) {
 function getCliPath() {
     return require.resolve(`../../bin/run-executor.js`);
 }
+function getUnparsedOverrideArgs(task) {
+    return task.overrides
+        .__overrides_unparsed__;
+}
 function getPrintableCommandArgsForTask(task) {
-    const args = task.overrides['__overrides_unparsed__'];
+    const args = getUnparsedOverrideArgs(task);
     const target = task.target.target.includes(':')
         ? `"${task.target.target}"`
         : task.target.target;
@@ -418,15 +423,6 @@ function shouldStreamOutput(task, initiatingProject) {
         return true;
     return false;
 }
-function isCacheableTask(task, options) {
-    if (task.cache !== undefined) {
-        return task.cache;
-    }
-    const cacheable = options.cacheableOperations || options.cacheableTargets;
-    return (cacheable &&
-        cacheable.indexOf(task.target.target) > -1 &&
-        !longRunningTask(task));
-}
 function longRunningTask(task) {
     const t = task.target.target;
     return (task.continuous ||