fix(core): enhance validation for continuous task dependencies

packages/nx/src/native/tests/watcher.spec.ts

@@ -106,7 +106,7 @@ describe('watcher', () => {
       await wait();
       temp.renameFile('app1/main.js', 'app1/rename.js');
     });
-  }, 15000);
+  }, 30000);
 
   it('should trigger on deletes', async () => {
     return new Promise<void>(async (done) => {

packages/nx/src/tasks-runner/task-graph-utils.spec.ts

@@ -1,11 +1,13 @@
 import '../internal-testing-utils/mock-fs';
 
 import {
+  assertTaskGraphDoesNotContainInvalidTargets,
   findCycle,
   findCycles,
   makeAcyclic,
   validateNoAtomizedTasks,
 } from './task-graph-utils';
+import { TaskGraph } from '../config/task-graph';
 
 describe('task graph utils', () => {
   describe('findCycle', () => {
@@ -310,4 +312,73 @@ describe('task graph utils', () => {
       expect(mockProcessExit).toHaveBeenCalledWith(1);
     });
   });
+
+  describe('assertTaskGraphDoesNotContainInvalidTargets', () => {
+    it('should throw if a task has parallelism set to false and has continuous dependencies', () => {
+      const taskGraph: TaskGraph = {
+        tasks: {
+          'a:build': {
+            id: 'a:build',
+            target: { project: 'a', target: 'build' },
+            parallelism: false,
+            overrides: {},
+            outputs: [],
+          },
+          'b:watch': {
+            id: 'b:watch',
+            target: { project: 'b', target: 'watch' },
+            parallelism: false,
+            overrides: {},
+            outputs: [],
+          },
+        },
+        continuousDependencies: {
+          'a:build': ['b:watch'],
+          'b:watch': [],
+        },
+        roots: ['a:build'],
+        dependencies: {
+          'a:build': [],
+          'b:watch': [],
+        },
+      };
+      expect(() => {
+        assertTaskGraphDoesNotContainInvalidTargets(taskGraph);
+      }).toThrowErrorMatchingInlineSnapshot(`
+        "The following tasks do not support parallelism but depend on continuous tasks:
+         - a:build -> b:watch"
+      `);
+    });
+
+    it('should throw if a task that is depended on and is continuous has parallelism set to false', () => {
+      const taskGraph: TaskGraph = {
+        tasks: {
+          'a:build': {
+            id: 'a:build',
+            target: { project: 'a', target: 'build' },
+            overrides: {},
+            outputs: [],
+            parallelism: true,
+          },
+          'b:watch': {
+            id: 'b:watch',
+            target: { project: 'b', target: 'watch' },
+            parallelism: false,
+            overrides: {},
+            outputs: [],
+          },
+        },
+        continuousDependencies: { 'a:build': ['b:watch'], 'b:watch': [] },
+        dependencies: { 'a:build': [], 'b:watch': [] },
+        roots: ['a:build'],
+      };
+      expect(() => {
+        assertTaskGraphDoesNotContainInvalidTargets(taskGraph);
+      }).toThrowErrorMatchingInlineSnapshot(`
+        "The following continuous tasks do not support parallelism but are depended on:
+         - b:watch <- a:build
+        Parallelism must be enabled for a continuous task if it is depended on, as the tasks that depend on it will run in parallel with it."
+      `);
+    });
+  });
 });

packages/nx/src/tasks-runner/task-graph-utils.ts

@@ -159,19 +159,33 @@ export function validateNoAtomizedTasks(
 export function assertTaskGraphDoesNotContainInvalidTargets(
   taskGraph: TaskGraph
 ) {
-  const invalidTasks = [];
+  const nonParallelTasksThatDependOnContinuousTasks = [];
+  const nonParallelContinuousTasksThatAreDependedOn = [];
   for (const task of Object.values(taskGraph.tasks)) {
     if (
       task.parallelism === false &&
       taskGraph.continuousDependencies[task.id].length > 0
     ) {
-      invalidTasks.push(task);
+      nonParallelTasksThatDependOnContinuousTasks.push(task);
+    }
+    for (const dependency of taskGraph.continuousDependencies[task.id]) {
+      if (taskGraph.tasks[dependency].parallelism === false) {
+        nonParallelContinuousTasksThatAreDependedOn.push(
+          taskGraph.tasks[dependency]
+        );
+      }
     }
   }
 
-  if (invalidTasks.length > 0) {
+  if (nonParallelTasksThatDependOnContinuousTasks.length > 0) {
     throw new NonParallelTaskDependsOnContinuousTasksError(
-      invalidTasks,
+      nonParallelTasksThatDependOnContinuousTasks,
+      taskGraph
+    );
+  }
+  if (nonParallelContinuousTasksThatAreDependedOn.length > 0) {
+    throw new DependingOnNonParallelContinuousTaskError(
+      nonParallelContinuousTasksThatAreDependedOn,
       taskGraph
     );
   }
@@ -193,6 +207,28 @@ class NonParallelTaskDependsOnContinuousTasksError extends Error {
   }
 }
 
+class DependingOnNonParallelContinuousTaskError extends Error {
+  constructor(public invalidTasks: Task[], taskGraph: 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)
+      );
+
+      message += `\n - ${task.id} <- ${dependents.join(', ')}`;
+    }
+
+    message +=
+      '\nParallelism must be enabled for a continuous task if it is depended on, as the tasks that depend on it will run in parallel with it.';
+
+    super(message);
+    this.name = 'DependingOnNonParallelContinuousTaskError';
+  }
+}
+
 export function getLeafTasks(taskGraph: TaskGraph): Set<string> {
   const reversed = reverseTaskGraph(taskGraph);
   const leafTasks = new Set<string>();