nx 23.3.0 → 24.0.0-beta.1

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

@@ -8,6 +8,9 @@ exports.assertTaskGraphDoesNotContainInvalidTargets = assertTaskGraphDoesNotCont
 exports.getLeafTasks = getLeafTasks;
 exports.walkTaskGraph = walkTaskGraph;
 const output_1 = require("../utils/output");
+function edgeId(edge) {
+    return typeof edge === 'string' ? edge : edge.id;
+}
 function _findCycle(graph, id, visited, path) {
     if (visited[id])
         return null;
@@ -15,7 +18,7 @@ function _findCycle(graph, id, visited, path) {
     for (const d of [
         ...graph.dependencies[id],
         ...(graph.continuousDependencies?.[id] ?? []),
-    ]) {
+    ].map(edgeId)) {
         if (path.includes(d))
             return [...path, d];
         const cycle = _findCycle(graph, d, visited, [...path, d]);
@@ -64,13 +67,13 @@ function _makeAcyclic(graph, id, visited, path) {
     visited[id] = true;
     const deps = graph.dependencies[id];
     const continuousDeps = graph.continuousDependencies?.[id] ?? [];
-    for (const d of [...deps, ...continuousDeps]) {
+    for (const d of [...deps, ...continuousDeps].map(edgeId)) {
         if (path.includes(d)) {
-            const depsIdx = deps.indexOf(d);
+            const depsIdx = deps.findIndex((edge) => edgeId(edge) === d);
             if (depsIdx >= 0) {
                 deps.splice(depsIdx, 1);
             }
-            const continuousIdx = continuousDeps.indexOf(d);
+            const continuousIdx = continuousDeps.findIndex((edge) => edgeId(edge) === d);
             if (continuousIdx >= 0) {
                 continuousDeps.splice(continuousIdx, 1);
             }
@@ -131,7 +134,7 @@ function assertTaskGraphDoesNotContainInvalidTargets(taskGraph) {
             taskGraph.continuousDependencies[task.id].length > 0) {
             nonParallelTasksThatDependOnContinuousTasks.push(task);
         }
-        for (const dependency of taskGraph.continuousDependencies[task.id]) {
+        for (const { id: dependency } of taskGraph.continuousDependencies[task.id]) {
             if (taskGraph.tasks[dependency].parallelism === false) {
                 nonParallelContinuousTasksThatAreDependedOn.push(taskGraph.tasks[dependency]);
             }
@@ -148,7 +151,9 @@ class NonParallelTaskDependsOnContinuousTasksError extends Error {
     constructor(invalidTasks, taskGraph) {
         let message = 'The following tasks do not support parallelism but depend on continuous tasks:';
         for (const task of invalidTasks) {
-            message += `\n - ${task.id} -> ${taskGraph.continuousDependencies[task.id].join(', ')}`;
+            message += `\n - ${task.id} -> ${taskGraph.continuousDependencies[task.id]
+                .map((edge) => edge.id)
+                .join(', ')}`;
         }
         super(message);
         this.invalidTasks = invalidTasks;
@@ -159,7 +164,7 @@ class DependingOnNonParallelContinuousTaskError extends Error {
     constructor(invalidTasks, taskGraph) {
         let message = 'The following continuous tasks do not support parallelism but are depended on:';
         for (const task of invalidTasks) {
-            const dependents = Object.keys(taskGraph.continuousDependencies).filter((parentTaskId) => taskGraph.continuousDependencies[parentTaskId].includes(task.id));
+            const dependents = Object.keys(taskGraph.continuousDependencies).filter((parentTaskId) => taskGraph.continuousDependencies[parentTaskId].some((edge) => edge.id === task.id));
             message += `\n - ${task.id} <- ${dependents.join(', ')}`;
         }
         message +=
@@ -185,13 +190,13 @@ function reverseTaskGraph(taskGraph) {
         dependencies: Object.fromEntries(Object.entries(taskGraph.tasks).map(([taskId]) => [taskId, []])),
     };
     for (const [taskId, dependencies] of Object.entries(taskGraph.dependencies)) {
-        for (const dependency of dependencies) {
-            reversed.dependencies[dependency].push(taskId);
+        for (const { id: dependency } of dependencies) {
+            reversed.dependencies[dependency].push({ id: taskId });
         }
     }
     for (const [taskId, dependencies] of Object.entries(taskGraph.continuousDependencies)) {
-        for (const dependency of dependencies) {
-            reversed.dependencies[dependency].push(taskId);
+        for (const { id: dependency } of dependencies) {
+            reversed.dependencies[dependency].push({ id: taskId });
         }
     }
     return reversed;
@@ -213,7 +218,7 @@ async function walkTaskGraph(taskGraph, walkFn) {
         await walkFn(currentRoots);
         const nextRoots = [];
         for (const id of currentRoots) {
-            for (const depId of reversed.dependencies[id] ?? []) {
+            for (const { id: depId } of reversed.dependencies[id] ?? []) {
                 inDegree[depId]--;
                 if (inDegree[depId] === 0) {
                     nextRoots.push(depId);

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

@@ -7,6 +7,7 @@ import { TaskHasher } from '../hasher/task-hasher';
 import { NxArgs } from '../utils/command-line-utils';
 import { DefaultTasksRunnerOptions } from './default-tasks-runner';
 import { TaskResult } from './life-cycle';
+import { NoopChildProcess } from './running-tasks/noop-child-process';
 import { RunningTask } from './running-tasks/running-task';
 import { SharedRunningTask } from './running-tasks/shared-running-task';
 import { TaskStatus } from './tasks-runner';
@@ -62,6 +63,11 @@ export declare class TaskOrchestrator {
     private runningDiscreteTasks;
     private discreteTaskExitHandled;
     private continuousTaskExitHandled;
+    private readiness;
+    private readinessFailures;
+    private readinessFailureReasons;
+    private readinessSettled;
+    private waitingLogged;
     private cleanupPromise;
     private signalHandlers;
     private tasksWithPersistedOutput;
@@ -91,15 +97,23 @@ export declare class TaskOrchestrator {
      */
     private executeCoordinatorLoop;
     private executeContinuousTaskLoop;
+    private hasUnresolvedCacheableTask;
+    private scheduleAfterReadiness;
     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.
+     * Registers a task invocation and checks for loops across nested Nx
+     * processes. registerTask() returns the invocation chain only when an
+     * *ancestor* Nx process is already running this task — a genuine loop.
+     * Sibling processes running the same task are legitimate and register
+     * without complaint.
+     *
+     * The overrides hash rides along with the task id so the tracker can tell an
+     * ancestor re-invoking a task with different arguments from one repeating
+     * the same invocation.
      */
     private detectTaskInvocationLoop;
+    private releaseTaskInvocation;
     private applyCachedResults;
     /**
      * Batch cache lookup + filter to successful entries. Handles both
@@ -244,14 +258,28 @@ export declare class TaskOrchestrator {
      */
     private handleDiscreteWorkerFailure;
     /**
-     * Spawn and wait on a task's child process, unconditionally — no cache
-     * lookup. Callers must have already confirmed the task is a cache miss
-     * (or disabled caching entirely).
+     * Spawn and wait on a task's child process once its ready dependencies are
+     * ready, with no cache lookup. Callers must have already confirmed the task
+     * is a cache miss (or disabled caching entirely).
      */
     runTaskDirectly(doNotSkipCache: boolean, task: Task, groupId: number): Promise<TaskResult>;
     private runTask;
     private runTaskInForkedProcess;
-    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
+    startContinuousTask(task: Task, groupId: number): Promise<NoopChildProcess | RunningTask | SharedRunningTask>;
+    private getReadyWhen;
+    private waitForReadyDependencies;
+    private onReadinessHold;
+    private pollReadinessRow;
+    private startReadinessProbe;
+    private failReadiness;
+    private hasReadyWaiter;
+    private skipWaiter;
+    private recordReadiness;
+    private readinessOf;
+    private armReadiness;
+    private abortReadiness;
+    private abortAllReadiness;
+    private failTaskBeforeStart;
     private preRunSteps;
     private postRunSteps;
     /**
@@ -297,6 +325,7 @@ export declare class TaskOrchestrator {
      */
     private recordContinuousTerminalOutput;
     private scheduleNextTasksAndReleaseThreads;
+    private releaseThreads;
     private complete;
     /**
      * Unified task completion handler for a set of tasks.