nx 21.0.0-beta.6 → 21.0.0-beta.8

package/src/tasks-runner/batch/run-batch.js

@@ -8,7 +8,7 @@ const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("../../command-line/run/executor-utils");
 function getBatchExecutor(executorName, projects) {
-    const [nodeModule, exportName] = executorName.split(':');
+    const [nodeModule, exportName] = (0, executor_utils_1.parseExecutor)(executorName);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);
 }
 async function runTasks(executorName, projectGraph, batchTaskGraph, fullTaskGraph) {

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

@@ -40,4 +40,3 @@ export declare function filterDummyTasks(dependencies: {
 export declare function getNonDummyDeps(currentTask: string, dependencies: {
     [k: string]: string[];
 }, cycles?: Set<string>, seen?: Set<string>): string[];
-export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;

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

@@ -5,7 +5,6 @@ exports.createTaskGraph = createTaskGraph;
 exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
 exports.filterDummyTasks = filterDummyTasks;
 exports.getNonDummyDeps = getNonDummyDeps;
-exports.createTaskId = createTaskId;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const output_1 = require("../utils/output");

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

@@ -1,8 +1,8 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
 import { NxArgs } from '../utils/command-line-utils';
 import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
 import type { ProjectGraph } from '../config/project-graph';
-import type { NxJsonConfiguration } from '../config/nx-json';
 import { RunningTask } from './running-tasks/running-task';
 /**
  * This function is deprecated. Do not use this

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

@@ -99,9 +99,15 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
             return acc;
         }, {}),
     };
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    const nxArgs = {
+        ...options,
+        parallel: tasks.length,
+        lifeCycle: compositedLifeCycle,
+    };
+    (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();
-    await Promise.all(tasks.map((task) => orchestrator.processTask(task.id)));
+    orchestrator.processTasks(tasks.map((task) => task.id));
     return orchestrator;
 }
 async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {

package/src/tasks-runner/life-cycle.d.ts

@@ -37,6 +37,8 @@ export interface LifeCycle {
     endTasks?(taskResults: TaskResult[], metadata: TaskMetadata): void | Promise<void>;
     printTaskTerminalOutput?(task: Task, status: TaskStatus, output: string): void;
     registerRunningTask?(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTaskWithEmptyParser?(taskId: string): void;
+    appendTaskOutput?(taskId: string, output: string): void;
     setTaskStatus?(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback?(callback: () => void): void;
 }
@@ -52,6 +54,8 @@ export declare class CompositeLifeCycle implements LifeCycle {
     endTasks(taskResults: TaskResult[], metadata: TaskMetadata): Promise<void>;
     printTaskTerminalOutput(task: Task, status: TaskStatus, output: string): void;
     registerRunningTask(taskId: string, parserAndWriter: ExternalObject<[any, any]>): void;
+    registerRunningTaskWithEmptyParser(taskId: string): void;
+    appendTaskOutput(taskId: string, output: string): void;
     setTaskStatus(taskId: string, status: NativeTaskStatus): void;
     registerForcedShutdownCallback(callback: () => void): void;
 }

package/src/tasks-runner/life-cycle.js

@@ -74,6 +74,20 @@ class CompositeLifeCycle {
             }
         }
     }
+    registerRunningTaskWithEmptyParser(taskId) {
+        for (let l of this.lifeCycles) {
+            if (l.registerRunningTaskWithEmptyParser) {
+                l.registerRunningTaskWithEmptyParser(taskId);
+            }
+        }
+    }
+    appendTaskOutput(taskId, output) {
+        for (let l of this.lifeCycles) {
+            if (l.appendTaskOutput) {
+                l.appendTaskOutput(taskId, output);
+            }
+        }
+    }
     setTaskStatus(taskId, status) {
         for (let l of this.lifeCycles) {
             if (l.setTaskStatus) {

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts

@@ -3,7 +3,9 @@ import { LifeCycle, TaskResult } from '../life-cycle';
 export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
+    private flakyTasks;
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
 }

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -31,24 +31,27 @@ class LegacyTaskHistoryLifeCycle {
     async endCommand() {
         await (0, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
         const history = await (0, legacy_task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
-        const flakyTasks = [];
+        this.flakyTasks = [];
         // check if any hash has different exit codes => flaky
         for (let hash in history) {
             if (history[hash].length > 1 &&
                 history[hash].some((run) => run.code !== history[hash][0].code)) {
-                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+                this.flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
             }
         }
         // Do not directly print output when using the TUI
         if ((0, is_tui_enabled_1.isTuiEnabled)()) {
             return;
         }
-        if (flakyTasks.length > 0) {
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks.length > 0) {
             output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((t) => `  ${t}`),
+                    ...this.flakyTasks.map((t) => `  ${t}`),
                     '',
                     `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
                 ],

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -1,10 +1,15 @@
 import { Task } from '../../config/task-graph';
 import { LifeCycle, TaskResult } from '../life-cycle';
+import { LegacyTaskHistoryLifeCycle } from './task-history-life-cycle-old';
+export declare function getTasksHistoryLifeCycle(): TaskHistoryLifeCycle | LegacyTaskHistoryLifeCycle | null;
 export declare class TaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
     private taskHistory;
+    private flakyTasks;
+    constructor();
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
 }

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -1,15 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskHistoryLifeCycle = void 0;
+exports.getTasksHistoryLifeCycle = getTasksHistoryLifeCycle;
+const native_1 = require("../../native");
 const output_1 = require("../../utils/output");
 const serialize_target_1 = require("../../utils/serialize-target");
 const task_history_1 = require("../../utils/task-history");
 const is_tui_enabled_1 = require("../is-tui-enabled");
+const task_history_life_cycle_old_1 = require("./task-history-life-cycle-old");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const nx_json_1 = require("../../config/nx-json");
+let tasksHistoryLifeCycle;
+function getTasksHistoryLifeCycle() {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        if (!tasksHistoryLifeCycle) {
+            tasksHistoryLifeCycle =
+                process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
+                    ? new TaskHistoryLifeCycle()
+                    : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle();
+        }
+        return tasksHistoryLifeCycle;
+    }
+    return null;
+}
 class TaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
         this.taskRuns = new Map();
         this.taskHistory = (0, task_history_1.getTaskHistory)();
+        if (tasksHistoryLifeCycle) {
+            throw new Error('TaskHistoryLifeCycle is a singleton and should not be instantiated multiple times');
+        }
+        tasksHistoryLifeCycle = this;
     }
     startTasks(tasks) {
         for (let task of tasks) {
@@ -36,17 +58,20 @@ class TaskHistoryLifeCycle {
             return;
         }
         await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
-        const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
+        this.flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
         // Do not directly print output when using the TUI
         if ((0, is_tui_enabled_1.isTuiEnabled)()) {
             return;
         }
-        if (flakyTasks.length > 0) {
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks.length > 0) {
             output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((hash) => {
+                    ...this.flakyTasks.map((hash) => {
                         const taskRun = this.taskRuns.get(hash);
                         return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
                     }),

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -7,6 +7,7 @@ const formatting_utils_1 = require("./formatting-utils");
 const pretty_time_1 = require("./pretty-time");
 const view_logs_utils_1 = require("./view-logs-utils");
 const figures = require("figures");
+const task_history_life_cycle_1 = require("./task-history-life-cycle");
 const LEFT_PAD = `   `;
 const SPACER = `  `;
 const EXTENDED_LEFT_PAD = `      `;
@@ -78,6 +79,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
         else {
             printRunManySummary();
         }
+        (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)()?.printFlakyTasksMessage();
     };
     const printRunOneSummary = () => {
         let lines = [];

package/src/tasks-runner/run-command.d.ts

@@ -17,6 +17,7 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<TaskResults>;
+export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
 export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;

package/src/tasks-runner/run-command.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
 exports.runCommandForTasks = runCommandForTasks;
+exports.setEnvVarsBasedOnArgs = setEnvVarsBasedOnArgs;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.constructLifeCycles = constructLifeCycles;
 exports.getRunner = getRunner;
@@ -14,7 +15,6 @@ const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
-const native_1 = require("../native");
 const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
 const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
@@ -34,7 +34,6 @@ const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/stat
 const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-terminal-output-life-cycle");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
-const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
@@ -633,10 +632,9 @@ function constructLifeCycles(lifeCycle) {
     if (process.env.NX_PROFILE) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
-    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
-        lifeCycles.push(process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
-            ? new task_history_life_cycle_1.TaskHistoryLifeCycle()
-            : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle());
+    const historyLifeCycle = (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)();
+    if (historyLifeCycle) {
+        lifeCycles.push(historyLifeCycle);
     }
     return lifeCycles;
 }

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

@@ -6,5 +6,6 @@ export declare abstract class RunningTask {
     }>;
     abstract onExit(cb: (code: number) => void): void;
     abstract kill(signal?: NodeJS.Signals | number): Promise<void> | void;
+    abstract onOutput?(cb: (output: string) => void): void;
     abstract send?(message: Serializable): void;
 }

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

@@ -42,7 +42,8 @@ export declare class TaskOrchestrator {
         [id: string]: TaskStatus;
     }>;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    processTask(taskId: string): Promise<NodeJS.ProcessEnv>;
+    processTasks(taskIds: string[]): void;
+    private processTask;
     private processScheduledBatch;
     private processAllScheduledTasks;
     private applyCachedResults;

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

@@ -124,6 +124,14 @@ class TaskOrchestrator {
         // block until some other task completes, then try again
         return new Promise((res) => this.waitingForTasks.push(res)).then(() => this.executeNextBatchOfTasksUsingTaskSchedule());
     }
+    processTasks(taskIds) {
+        for (const taskId of taskIds) {
+            // Task is already handled or being handled
+            if (!this.processedTasks.has(taskId)) {
+                this.processedTasks.set(taskId, this.processTask(taskId));
+            }
+        }
+    }
     // region Processing Scheduled Tasks
     async processTask(taskId) {
         const task = this.taskGraph.tasks[taskId];
@@ -147,12 +155,7 @@ class TaskOrchestrator {
         for (const batch of scheduledBatches) {
             this.processedBatches.set(batch, this.processScheduledBatch(batch));
         }
-        for (const taskId of scheduledTasks) {
-            // Task is already handled or being handled
-            if (!this.processedTasks.has(taskId)) {
-                this.processedTasks.set(taskId, this.processTask(taskId));
-            }
-        }
+        this.processTasks(scheduledTasks);
     }
     // endregion Processing Scheduled Tasks
     // region Applying Cache
@@ -302,9 +305,17 @@ class TaskOrchestrator {
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
                 });
-                if (this.tuiEnabled && runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
-                    // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                if (this.tuiEnabled) {
+                    if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                        // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
+                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                    }
+                    else {
+                        this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
+                        runningTask.onOutput((output) => {
+                            this.options.lifeCycle.appendTaskOutput(task.id, output);
+                        });
+                    }
                 }
                 if (!streamOutput) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
@@ -352,9 +363,17 @@ class TaskOrchestrator {
         else {
             // cache prep
             const runningTask = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-            if (this.tuiEnabled && runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
-                // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
-                this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+            if (this.tuiEnabled) {
+                if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
+                    // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                }
+                else if ('onOutput' in runningTask) {
+                    this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
+                    runningTask.onOutput((output) => {
+                        this.options.lifeCycle.appendTaskOutput(task.id, output);
+                    });
+                }
             }
             return runningTask;
         }

package/src/tasks-runner/utils.js

@@ -294,7 +294,7 @@ function getExecutorNameForTask(task, projectGraph) {
 }
 function getExecutorForTask(task, projectGraph) {
     const executor = getExecutorNameForTask(task, projectGraph);
-    const [nodeModule, executorName] = executor.split(':');
+    const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
 }
 function getCustomHasher(task, projectGraph) {
@@ -374,6 +374,8 @@ function shouldStreamOutput(task, initiatingProject) {
         return false;
     if (process.env.NX_STREAM_OUTPUT === 'true')
         return true;
+    if (process.env.NX_STREAM_OUTPUT === 'false')
+        return false;
     if (longRunningTask(task))
         return true;
     if (task.target.project === initiatingProject)

package/src/utils/package-json.d.ts

@@ -74,7 +74,7 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
 export declare function buildTargetFromScript(script: string, scripts: Record<string, string>, packageManagerCommand: PackageManagerCommands): TargetConfiguration;
 export declare function getMetadataFromPackageJson(packageJson: PackageJson, isInPackageManagerWorkspaces: boolean): ProjectMetadata;
 export declare function getTagsFromPackageJson(packageJson: PackageJson): string[];
-export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration): Record<string, TargetConfiguration<any>>;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration, projectRoot: string, workspaceRoot: string): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/utils/package-json.js

@@ -83,7 +83,7 @@ function getTagsFromPackageJson(packageJson) {
     }
     return tags;
 }
-function readTargetsFromPackageJson(packageJson, nxJson) {
+function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot) {
     const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
@@ -102,7 +102,9 @@ function readTargetsFromPackageJson(packageJson, nxJson) {
      * Any targetDefaults for the nx-release-publish target set by the user should
      * be merged with the implicit target.
      */
-    if (!isPrivate && !res['nx-release-publish']) {
+    if (!isPrivate &&
+        !res['nx-release-publish'] &&
+        hasNxJsPlugin(projectRoot, workspaceRoot)) {
         const nxReleasePublishTargetDefaults = nxJson?.targetDefaults?.['nx-release-publish'] ?? {};
         res['nx-release-publish'] = {
             executor: '@nx/js:release-publish',
@@ -119,6 +121,18 @@ function readTargetsFromPackageJson(packageJson, nxJson) {
     }
     return res;
 }
+function hasNxJsPlugin(projectRoot, workspaceRoot) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/js', {
+            paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *