nx 21.0.0-beta.1 → 21.0.0-beta.11

package/src/tasks-runner/running-tasks/shared-running-task.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedRunningTask = void 0;
+class SharedRunningTask {
+    constructor(runningTasksService, taskId) {
+        this.runningTasksService = runningTasksService;
+        this.exitCallbacks = [];
+        this.waitForTaskToFinish(taskId).then(() => {
+            // notify exit callbacks
+            this.exitCallbacks.forEach((cb) => cb(0));
+        });
+    }
+    async getResults() {
+        throw new Error('Results cannot be retrieved from a shared task');
+    }
+    kill() {
+        this.exitCallbacks.forEach((cb) => cb(0));
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    async waitForTaskToFinish(taskId) {
+        console.log(`Waiting for ${taskId} in another nx process`);
+        // wait for the running task to finish
+        do {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        } while (this.runningTasksService.getRunningTasks([taskId]).length);
+    }
+}
+exports.SharedRunningTask = SharedRunningTask;

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

@@ -1,10 +1,7 @@
 import { Task } from '../config/task-graph';
 export declare function getEnvVariablesForBatchProcess(skipNxCache: boolean, captureStderr: boolean): NodeJS.ProcessEnv;
 export declare function getTaskSpecificEnv(task: Task): NodeJS.ProcessEnv;
-export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): {
-    [x: string]: string;
-    TZ?: string;
-};
+export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: NodeJS.ProcessEnv, forceColor: string, skipNxCache: boolean, captureStderr: boolean, outputPath: string, streamOutput: boolean): NodeJS.ProcessEnv;
 /**
  * This function loads a .env file and expands the variables in it.
  * @param filename the .env file to load

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

@@ -75,6 +75,8 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
     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',
     };
 }
 /**

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

@@ -6,6 +6,7 @@ import { TaskGraph } from '../config/task-graph';
  */
 export declare function findCycle(graph: {
     dependencies: Record<string, string[]>;
+    continuousDependencies?: Record<string, string[]>;
 }): string[] | null;
 /**
  * This function finds all cycles in the graph.
@@ -13,9 +14,11 @@ export declare function findCycle(graph: {
  */
 export declare function findCycles(graph: {
     dependencies: Record<string, string[]>;
+    continuousDependencies?: Record<string, string[]>;
 }): Set<string> | null;
 export declare function makeAcyclic(graph: {
     roots: string[];
     dependencies: Record<string, string[]>;
 }): void;
 export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;
+export declare function assertTaskGraphDoesNotContainInvalidTargets(taskGraph: TaskGraph): void;

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

@@ -4,12 +4,16 @@ exports.findCycle = findCycle;
 exports.findCycles = findCycles;
 exports.makeAcyclic = makeAcyclic;
 exports.validateNoAtomizedTasks = validateNoAtomizedTasks;
+exports.assertTaskGraphDoesNotContainInvalidTargets = assertTaskGraphDoesNotContainInvalidTargets;
 const output_1 = require("../utils/output");
 function _findCycle(graph, id, visited, path) {
     if (visited[id])
         return null;
     visited[id] = true;
-    for (const d of graph.dependencies[id]) {
+    for (const d of [
+        ...graph.dependencies[id],
+        ...(graph.continuousDependencies?.[id] ?? []),
+    ]) {
         if (path.includes(d))
             return [...path, d];
         const cycle = _findCycle(graph, d, visited, [...path, d]);
@@ -57,9 +61,11 @@ function _makeAcyclic(graph, id, visited, path) {
         return;
     visited[id] = true;
     const deps = graph.dependencies[id];
-    for (const d of [...deps]) {
+    const continuousDeps = graph.continuousDependencies?.[id] ?? [];
+    for (const d of [...deps, ...continuousDeps]) {
         if (path.includes(d)) {
             deps.splice(deps.indexOf(d), 1);
+            continuousDeps.splice(continuousDeps.indexOf(d), 1);
         }
         else {
             _makeAcyclic(graph, d, visited, [...path, d]);
@@ -109,3 +115,26 @@ function validateNoAtomizedTasks(taskGraph, projectGraph) {
     }
     process.exit(1);
 }
+function assertTaskGraphDoesNotContainInvalidTargets(taskGraph) {
+    const invalidTasks = [];
+    for (const task of Object.values(taskGraph.tasks)) {
+        if (task.parallelism === false &&
+            taskGraph.continuousDependencies[task.id].length > 0) {
+            invalidTasks.push(task);
+        }
+    }
+    if (invalidTasks.length > 0) {
+        throw new NonParallelTaskDependsOnContinuousTasksError(invalidTasks, taskGraph);
+    }
+}
+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(', ')}`;
+        }
+        super(message);
+        this.invalidTasks = invalidTasks;
+        this.name = 'NonParallelTaskDependsOnContinuousTasksError';
+    }
+}

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

@@ -1,14 +1,17 @@
-import { TaskHasher } from '../hasher/task-hasher';
-import { DefaultTasksRunnerOptions } from './default-tasks-runner';
-import { TaskStatus } from './tasks-runner';
+import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
-import { TaskGraph } from '../config/task-graph';
+import { Task, TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
-import { NxJsonConfiguration } from '../config/nx-json';
+import { TaskHasher } from '../hasher/task-hasher';
 import { NxArgs } from '../utils/command-line-utils';
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { RunningTask } from './running-tasks/running-task';
+import { TaskStatus } from './tasks-runner';
+import { SharedRunningTask } from './running-tasks/shared-running-task';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
+    private readonly initiatingTasks;
     private readonly projectGraph;
     private readonly taskGraph;
     private readonly nxJson;
@@ -16,12 +19,16 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private readonly taskGraphForHashing;
     private taskDetails;
     private cache;
+    private readonly tuiEnabled;
     private forkedProcessTaskRunner;
+    private runningTasksService;
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
+    private initializingTaskIds;
     private processedTasks;
     private processedBatches;
     private completedTasks;
@@ -29,25 +36,32 @@ export declare class TaskOrchestrator {
     private groups;
     private bailed;
     private runningContinuousTasks;
-    private cleaningUp;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, taskGraphForHashing?: TaskGraph);
+    init(): Promise<void>;
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    private processScheduledTask;
+    processTasks(taskIds: string[]): void;
+    private processTask;
     private processScheduledBatch;
     private processAllScheduledTasks;
     private applyCachedResults;
     private applyCachedResult;
     private applyFromCacheOrRunBatch;
     private runBatch;
-    private applyFromCacheOrRunTask;
+    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<{
+        task: Task;
+        code: number;
+        status: TaskStatus;
+        terminalOutput?: string;
+    }>;
     private runTask;
     private runTaskInForkedProcess;
-    private startContinuousTask;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
     private preRunSteps;
     private postRunSteps;
+    private scheduleNextTasksAndReleaseThreads;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;
@@ -56,4 +70,6 @@ export declare class TaskOrchestrator {
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
     private cleanup;
+    private cleanUpUnneededContinuousTasks;
 }
+export declare function getThreadCount(options: NxArgs & DefaultTasksRunnerOptions, taskGraph: TaskGraph): number;