nx 21.0.0-canary.20250502-110614d → 21.0.0-rc.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.0.0-canary.20250502-110614d",
+  "version": "21.0.0-rc.1",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-darwin-x64": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-freebsd-x64": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-linux-arm-gnueabihf": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-linux-arm64-gnu": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-linux-arm64-musl": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-linux-x64-gnu": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-linux-x64-musl": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-win32-arm64-msvc": "21.0.0-canary.20250502-110614d",
-    "@nx/nx-win32-x64-msvc": "21.0.0-canary.20250502-110614d"
+    "@nx/nx-darwin-arm64": "21.0.0-rc.1",
+    "@nx/nx-darwin-x64": "21.0.0-rc.1",
+    "@nx/nx-freebsd-x64": "21.0.0-rc.1",
+    "@nx/nx-linux-arm-gnueabihf": "21.0.0-rc.1",
+    "@nx/nx-linux-arm64-gnu": "21.0.0-rc.1",
+    "@nx/nx-linux-arm64-musl": "21.0.0-rc.1",
+    "@nx/nx-linux-x64-gnu": "21.0.0-rc.1",
+    "@nx/nx-linux-x64-musl": "21.0.0-rc.1",
+    "@nx/nx-win32-arm64-msvc": "21.0.0-rc.1",
+    "@nx/nx-win32-x64-msvc": "21.0.0-rc.1"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -18,10 +18,5 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
         taskResults: Record<string, TaskResult>;
     }>;
 }>;
-export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Promise<{
-    task: Task;
-    code: number;
-    status: import("./tasks-runner").TaskStatus;
-    terminalOutput?: string;
-}>[]>;
+export declare function runDiscreteTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Array<Promise<TaskResult[]>>>;
 export declare function runContinuousTasks(tasks: Task[], projectGraph: ProjectGraph, taskGraphForHashing: TaskGraph, nxJson: NxJsonConfiguration, lifeCycle: LifeCycle): Promise<Record<string, Promise<RunningTask>>>;

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

@@ -107,12 +107,32 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
     (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
     const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
     await orchestrator.init();
-    orchestrator.processTasks(tasks.map((task) => task.id));
+    orchestrator.processAllScheduledTasks();
     return orchestrator;
 }
 async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);
-    return tasks.map((task, index) => orchestrator.applyFromCacheOrRunTask(true, task, index));
+    let groupId = 0;
+    let nextBatch = orchestrator.nextBatch();
+    let batchResults = [];
+    /**
+     * Set of task ids that were part of batches
+     */
+    const batchTasks = new Set();
+    while (nextBatch) {
+        for (const task in nextBatch.taskGraph.tasks) {
+            batchTasks.add(task);
+        }
+        batchResults.push(orchestrator.applyFromCacheOrRunBatch(true, nextBatch, groupId++));
+        nextBatch = orchestrator.nextBatch();
+    }
+    const taskResults = tasks
+        // Filter out tasks which were not part of batches
+        .filter((task) => !batchTasks.has(task.id))
+        .map((task) => orchestrator
+        .applyFromCacheOrRunTask(true, task, groupId++)
+        .then((r) => [r]));
+    return [...batchResults, ...taskResults];
 }
 async function runContinuousTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {
     const orchestrator = await createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle);

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

@@ -5,8 +5,10 @@ import { DaemonClient } from '../daemon/client/client';
 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 { RunningTask } from './running-tasks/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;
@@ -41,21 +43,17 @@ export declare class TaskOrchestrator {
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
+    nextBatch(): Batch;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    processTasks(taskIds: string[]): void;
+    private processTasks;
     private processTask;
     private processScheduledBatch;
-    private processAllScheduledTasks;
+    processAllScheduledTasks(): void;
     private applyCachedResults;
     private applyCachedResult;
-    private applyFromCacheOrRunBatch;
+    applyFromCacheOrRunBatch(doNotSkipCache: boolean, batch: Batch, groupId: number): Promise<TaskResult[]>;
     private runBatch;
-    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<{
-        task: Task;
-        code: number;
-        status: TaskStatus;
-        terminalOutput?: string;
-    }>;
+    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<TaskResult>;
     private runTask;
     private runTaskInForkedProcess;
     startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;

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

@@ -60,14 +60,14 @@ class TaskOrchestrator {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
         await Promise.all([
             this.forkedProcessTaskRunner.init(),
-            this.tasksSchedule.init(),
+            this.tasksSchedule.init().then(() => {
+                return this.tasksSchedule.scheduleNextTasks();
+            }),
             'init' in this.cache ? this.cache.init() : null,
         ]);
     }
     async run() {
         await this.init();
-        // initial scheduling
-        await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
         const threadCount = getThreadCount(this.options, this.taskGraph);
         const threads = [];
@@ -96,6 +96,9 @@ class TaskOrchestrator {
         await this.cleanup();
         return this.completedTasks;
     }
+    nextBatch() {
+        return this.tasksSchedule.nextBatch();
+    }
     async executeNextBatchOfTasksUsingTaskSchedule() {
         // completed all the tasks
         if (!this.tasksSchedule.hasTasks() || this.bailed) {
@@ -104,7 +107,7 @@ class TaskOrchestrator {
         const doNotSkipCache = this.options.skipNxCache === false ||
             this.options.skipNxCache === undefined;
         this.processAllScheduledTasks();
-        const batch = this.tasksSchedule.nextBatch();
+        const batch = this.nextBatch();
         if (batch) {
             const groupId = this.closeGroup();
             await this.applyFromCacheOrRunBatch(doNotSkipCache, batch, groupId);
@@ -202,7 +205,9 @@ class TaskOrchestrator {
         // Wait for batch to be processed
         await this.processedBatches.get(batch);
         await this.preRunSteps(tasks, { groupId });
-        let results = doNotSkipCache ? await this.applyCachedResults(tasks) : [];
+        let results = doNotSkipCache
+            ? await this.applyCachedResults(tasks)
+            : [];
         // Run tasks that were not cached
         if (results.length !== taskEntries.length) {
             const unrunTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(batch.taskGraph, results.map(({ task }) => task.id));
@@ -225,6 +230,7 @@ class TaskOrchestrator {
         // Batch is done, mark it as completed
         const applyFromCacheOrRunBatchEnd = perf_hooks_1.performance.mark('TaskOrchestrator-apply-from-cache-or-run-batch:end');
         perf_hooks_1.performance.measure('TaskOrchestrator-apply-from-cache-or-run-batch', applyFromCacheOrRunBatchStart.name, applyFromCacheOrRunBatchEnd.name);
+        return results;
     }
     async runBatch(batch, env) {
         const runBatchStart = perf_hooks_1.performance.mark('TaskOrchestrator-run-batch:start');
@@ -234,6 +240,7 @@ class TaskOrchestrator {
             const batchResultEntries = Object.entries(results);
             return batchResultEntries.map(([taskId, result]) => ({
                 ...result,
+                code: result.success ? 0 : 1,
                 task: {
                     ...this.taskGraph.tasks[taskId],
                     startTime: result.startTime,
@@ -246,6 +253,7 @@ class TaskOrchestrator {
         catch (e) {
             return batch.taskGraph.roots.map((rootTaskId) => ({
                 task: this.taskGraph.tasks[rootTaskId],
+                code: 1,
                 status: 'failure',
             }));
         }