nx 19.5.0-canary.20240712-0b0db78 → 19.5.0-canary.20240716-34da542

package/src/native/index.d.ts

@@ -185,6 +185,7 @@ export interface Target {
   outputs?: Array<string>
   options?: string
   configurations?: string
+  parallelism?: boolean
 }
 
 export interface Task {

package/src/native/transform-objects.js

@@ -14,6 +14,7 @@ function transformProjectGraphForRust(graph) {
                 outputs: targetConfig.outputs,
                 options: JSON.stringify(targetConfig.options),
                 configurations: JSON.stringify(targetConfig.configurations),
+                parallelism: targetConfig.parallelism,
             };
         }
         nodes[projectName] = {

package/src/project-graph/utils/project-configuration-utils.js

@@ -18,6 +18,7 @@ const minimatch_1 = require("minimatch");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const error_types_1 = require("../error-types");
+const globs_1 = require("../../utils/globs");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -709,10 +710,23 @@ function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
         const key = [executor, targetName].find((x) => targetDefaults?.[x]);
         return key ? targetDefaults?.[key] : null;
     }
-    else {
+    else if (targetDefaults?.[targetName]) {
         // If the executor is not defined, the only key we have is the target name.
         return targetDefaults?.[targetName];
     }
+    let matchingTargetDefaultKey = null;
+    for (const key in targetDefaults ?? {}) {
+        if ((0, globs_1.isGlobPattern)(key) && (0, minimatch_1.minimatch)(targetName, key)) {
+            if (!matchingTargetDefaultKey ||
+                matchingTargetDefaultKey.length < key.length) {
+                matchingTargetDefaultKey = key;
+            }
+        }
+    }
+    if (matchingTargetDefaultKey) {
+        return targetDefaults[matchingTargetDefaultKey];
+    }
+    return {};
 }
 function createRootMap(projectRootMap) {
     const map = {};
@@ -748,11 +762,17 @@ function resolveCommandSyntacticSugar(target, key) {
  * @returns The normalized target configuration
  */
 function normalizeTarget(target, project) {
+    target = {
+        ...target,
+        configurations: {
+            ...target.configurations,
+        },
+    };
     target = resolveCommandSyntacticSugar(target, project.root);
     target.options = resolveNxTokensInOptions(target.options, project, `${project.root}:${target}`);
-    target.configurations ??= {};
     for (const configuration in target.configurations) {
         target.configurations[configuration] = resolveNxTokensInOptions(target.configurations[configuration], project, `${project.root}:${target}:${configuration}`);
     }
+    target.parallelism ??= true;
     return target;
 }

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

@@ -156,6 +156,7 @@ class ProcessTasks {
             overrides: interpolatedOverrides,
             outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
             cache: project.data.targets[target].cache,
+            parallelism: project.data.targets[target].parallelism ?? true,
         };
     }
     resolveConfiguration(project, target, configuration) {

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

@@ -14,6 +14,7 @@ export declare class TasksSchedule {
     private reverseProjectGraph;
     private scheduledBatches;
     private scheduledTasks;
+    private runningTasks;
     private completedTasks;
     private scheduleRequestsExecutionChain;
     constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);

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

@@ -14,6 +14,7 @@ class TasksSchedule {
         this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
         this.scheduledBatches = [];
         this.scheduledTasks = [];
+        this.runningTasks = new Set();
         this.completedTasks = new Set();
         this.scheduleRequestsExecutionChain = Promise.resolve();
     }
@@ -31,6 +32,7 @@ class TasksSchedule {
     complete(taskIds) {
         for (const taskId of taskIds) {
             this.completedTasks.add(taskId);
+            this.runningTasks.delete(taskId);
         }
         this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, taskIds);
     }
@@ -84,6 +86,7 @@ class TasksSchedule {
                 (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph)
                     .length);
         });
+        this.runningTasks.add(taskId);
     }
     async scheduleBatches() {
         const batchMap = {};
@@ -102,7 +105,7 @@ class TasksSchedule {
         this.scheduledBatches.push({ executorName, taskGraph });
     }
     async processTaskForBatches(batches, task, rootExecutorName, isRoot) {
-        if (!this.canBatchTaskBeScheduled(task.id, batches[rootExecutorName])) {
+        if (!this.canBatchTaskBeScheduled(task, batches[rootExecutorName])) {
             return;
         }
         const { batchImplementationFactory } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
@@ -131,12 +134,33 @@ class TasksSchedule {
             await this.processTaskForBatches(batches, depTask, rootExecutorName, false);
         }
     }
-    canBatchTaskBeScheduled(taskId, batchTaskGraph) {
+    canBatchTaskBeScheduled(task, batchTaskGraph) {
+        // task self needs to have parallelism true
         // all deps have either completed or belong to the same batch
-        return this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]);
+        return (task.parallelism === true &&
+            this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
     }
     canBeScheduled(taskId) {
-        return this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
+        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
+        // if dependencies have not completed, cannot schedule
+        if (!hasDependenciesCompleted) {
+            return false;
+        }
+        // if there are no running tasks, can schedule anything
+        if (this.runningTasks.size === 0) {
+            return true;
+        }
+        const runningTasksNotSupportParallelism = Array.from(this.runningTasks).some((taskId) => {
+            return this.taskGraph.tasks[taskId].parallelism === false;
+        });
+        if (runningTasksNotSupportParallelism) {
+            // if any running tasks do not support parallelism, no other tasks can be scheduled
+            return false;
+        }
+        else {
+            // if all running tasks support parallelism, can only schedule task with parallelism
+            return this.taskGraph.tasks[taskId].parallelism === true;
+        }
     }
 }
 exports.TasksSchedule = TasksSchedule;

package/src/tasks-runner/utils.js

@@ -36,6 +36,7 @@ const executor_utils_1 = require("../command-line/run/executor-utils");
 const project_graph_1 = require("../project-graph/project-graph");
 const find_matching_projects_1 = require("../utils/find-matching-projects");
 const minimatch_1 = require("minimatch");
+const globs_1 = require("../utils/globs");
 function getDependencyConfigs({ project, target }, extraTargetDependencies, projectGraph, allTargetNames) {
     const dependencyConfigs = (projectGraph.nodes[project].data?.targets[target]?.dependsOn ??
         // This is passed into `run-command` from programmatic invocations
@@ -77,7 +78,7 @@ function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph) {
 // Weakmap let's the cache get cleared by garbage collector if allTargetNames is no longer used
 const patternResultCache = new WeakMap();
 function expandWildcardTargetConfiguration(dependencyConfig, allTargetNames) {
-    if (!find_matching_projects_1.GLOB_CHARACTERS.some((char) => dependencyConfig.target.includes(char))) {
+    if (!(0, globs_1.isGlobPattern)(dependencyConfig.target)) {
         return [dependencyConfig];
     }
     let cache = patternResultCache.get(allTargetNames);

package/src/utils/find-matching-projects.d.ts

@@ -1,8 +1,4 @@
 import type { ProjectGraphProjectNode } from '../config/project-graph';
-/**
- * The presence of these characters in a string indicates that it might be a glob pattern.
- */
-export declare const GLOB_CHARACTERS: string[];
 /**
  * Find matching project names given a list of potential project names or globs.
  *

package/src/utils/find-matching-projects.js

@@ -1,18 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMatchingStringsWithCache = exports.GLOB_CHARACTERS = void 0;
+exports.getMatchingStringsWithCache = void 0;
 exports.findMatchingProjects = findMatchingProjects;
 const minimatch_1 = require("minimatch");
+const globs_1 = require("./globs");
 const validPatternTypes = [
     'name', // Pattern is based on the project's name
     'tag', // Pattern is based on the project's tags
     'directory', // Pattern is based on the project's root directory
     'unlabeled', // Pattern was passed without specifying a type
 ];
-/**
- * The presence of these characters in a string indicates that it might be a glob pattern.
- */
-exports.GLOB_CHARACTERS = ['*', '|', '{', '}', '(', ')'];
 /**
  * Find matching project names given a list of potential project names or globs.
  *
@@ -113,7 +110,7 @@ function addMatchingProjectsByName(projectNames, projects, pattern, matchedProje
         }
         return;
     }
-    if (!exports.GLOB_CHARACTERS.some((c) => pattern.value.includes(c))) {
+    if (!(0, globs_1.isGlobPattern)(pattern.value)) {
         return;
     }
     const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);
@@ -138,7 +135,7 @@ function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjec
             }
             continue;
         }
-        if (!exports.GLOB_CHARACTERS.some((c) => pattern.value.includes(c))) {
+        if (!(0, globs_1.isGlobPattern)(pattern.value)) {
             continue;
         }
         if ((0, exports.getMatchingStringsWithCache)(pattern.value, tags).length) {

package/src/utils/globs.d.ts

@@ -1 +1,3 @@
 export declare function combineGlobPatterns(...patterns: (string | string[])[]): string;
+export declare const GLOB_CHARACTERS: Set<string>;
+export declare function isGlobPattern(pattern: string): boolean;

package/src/utils/globs.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOB_CHARACTERS = void 0;
 exports.combineGlobPatterns = combineGlobPatterns;
+exports.isGlobPattern = isGlobPattern;
 function combineGlobPatterns(...patterns) {
     const p = patterns.flat();
     return p.length > 1 ? '{' + p.join(',') + '}' : p.length === 1 ? p[0] : '';
 }
+exports.GLOB_CHARACTERS = new Set(['*', '|', '{', '}', '(', ')', '[']);
+function isGlobPattern(pattern) {
+    for (const c of pattern) {
+        if (exports.GLOB_CHARACTERS.has(c)) {
+            return true;
+        }
+    }
+    return false;
+}