nx 24.0.0-beta.0 → 24.0.0-beta.2

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';
@@ -27,7 +28,7 @@ export declare class TaskOrchestrator {
     private readonly resolvedOutputStyle;
     private readonly fullTaskGraph;
     /** Tasks the up-front pass left to hash once the tasks they read from have run. */
-    private readonly deferredTaskIds?;
+    private readonly hashingDeferredTaskIds?;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -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;
@@ -73,7 +79,7 @@ export declare class TaskOrchestrator {
     /** What this run renders with, after defaults. */
     resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph, 
     /** Tasks the up-front pass left to hash once the tasks they read from have run. */
-    deferredTaskIds?: ReadonlySet<string>);
+    hashingDeferredTaskIds?: ReadonlySet<string>);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;
@@ -91,6 +97,8 @@ export declare class TaskOrchestrator {
      */
     private executeCoordinatorLoop;
     private executeContinuousTaskLoop;
+    private hasUnresolvedCacheableTask;
+    private scheduleAfterReadiness;
     private processTask;
     processAllScheduledTasks(): void;
     /**
@@ -138,14 +146,18 @@ export declare class TaskOrchestrator {
     /**
      * Hash all batch tasks and resolve cache hits topologically.
      *
-     * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
-     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
-     * receive a preliminary hash — they'll be re-hashed after execution.
+     * Walks the task graph level by level. A deferred task (its hash reads
+     * another task's outputs) behind an upstream batch task that still has to
+     * run is never looked up yet:
+     * - behind a non-cacheable task only, it is held back for a later wave,
+     *   where it hashes after that task ran;
+     * - behind a cache miss, it runs in this wave and re-hashes after execution.
+     * Every task run in this wave gets a hash first, for Cloud's startTasks.
      */
     private applyBatchCachedResults;
     private hashBatchTasks;
     applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
+    private runBatchWave;
     private runBatch;
     /**
      * Tells the life cycle where the batch worker's own log is, when something
@@ -250,14 +262,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;
     /**
@@ -303,6 +329,7 @@ export declare class TaskOrchestrator {
      */
     private recordContinuousTerminalOutput;
     private scheduleNextTasksAndReleaseThreads;
+    private releaseThreads;
     private complete;
     /**
      * Unified task completion handler for a set of tasks.