nx 20.4.0-canary.20250125-15fc599 → 20.4.0-rc.0

package/src/project-graph/plugins/tasks-execution-hooks.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPreTasksExecution = runPreTasksExecution;
+exports.runPostTasksExecution = runPostTasksExecution;
+const get_plugins_1 = require("./get-plugins");
+const is_on_daemon_1 = require("../../daemon/is-on-daemon");
+const client_1 = require("../../daemon/client/client");
+async function runPreTasksExecution(pluginContext) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        performance.mark(`preTasksExecution:start`);
+        const plugins = await (0, get_plugins_1.getPlugins)(pluginContext.workspaceRoot);
+        const envs = await Promise.all(plugins
+            .filter((p) => p.preTasksExecution)
+            .map(async (plugin) => {
+            performance.mark(`${plugin.name}:preTasksExecution:start`);
+            try {
+                return await plugin.preTasksExecution(pluginContext);
+            }
+            finally {
+                performance.mark(`${plugin.name}:preTasksExecution:end`);
+                performance.measure(`${plugin.name}:preTasksExecution`, `${plugin.name}:preTasksExecution:start`, `${plugin.name}:preTasksExecution:end`);
+            }
+        }));
+        if (!(0, client_1.isDaemonEnabled)()) {
+            applyProcessEnvs(envs);
+        }
+        performance.mark(`preTasksExecution:end`);
+        performance.measure(`preTasksExecution`, `preTasksExecution:start`, `preTasksExecution:end`);
+        return envs;
+    }
+    else {
+        const envs = await client_1.daemonClient.runPreTasksExecution(pluginContext);
+        applyProcessEnvs(envs);
+    }
+}
+function applyProcessEnvs(envs) {
+    for (const env of envs) {
+        for (const key in env) {
+            process.env[key] = env[key];
+        }
+    }
+}
+async function runPostTasksExecution(context) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !(0, client_1.isDaemonEnabled)()) {
+        performance.mark(`postTasksExecution:start`);
+        const plugins = await (0, get_plugins_1.getPlugins)();
+        await Promise.all(plugins
+            .filter((p) => p.postTasksExecution)
+            .map(async (plugin) => {
+            performance.mark(`${plugin.name}:postTasksExecution:start`);
+            try {
+                await plugin.postTasksExecution(context);
+            }
+            finally {
+                performance.mark(`${plugin.name}:postTasksExecution:end`);
+                performance.measure(`${plugin.name}:postTasksExecution`, `${plugin.name}:postTasksExecution:start`, `${plugin.name}:postTasksExecution:end`);
+            }
+        }));
+        performance.mark(`postTasksExecution:end`);
+        performance.measure(`postTasksExecution`, `postTasksExecution:start`, `postTasksExecution:end`);
+    }
+    else {
+        await client_1.daemonClient.runPostTasksExecution(context);
+    }
+}

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -52,7 +52,7 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
             (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
         pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
     }
-    const plugins = await (0, get_plugins_1.getPlugins)();
+    const plugins = await (0, get_plugins_1.getPlugins)(workspaceRoot);
     const res = await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
     return res;
 }

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

@@ -1,11 +1,18 @@
 import { TaskStatus } from './tasks-runner';
 import { Task } from '../config/task-graph';
+/**
+ * The result of a completed {@link Task}
+ */
 export interface TaskResult {
     task: Task;
     status: TaskStatus;
     code: number;
     terminalOutput?: string;
 }
+/**
+ * A map of {@link TaskResult} keyed by the ID of the completed {@link Task}s
+ */
+export type TaskResults = Record<string, TaskResult>;
 export interface TaskMetadata {
     groupId: number;
 }

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

@@ -3,7 +3,7 @@ import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
-import { LifeCycle, TaskResult } from './life-cycle';
+import { LifeCycle, TaskResult, TaskResults } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
 export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
@@ -16,9 +16,7 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
-}): Promise<{
-    [id: string]: TaskResult;
-}>;
+}): Promise<TaskResults>;
 export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;

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

@@ -37,6 +37,7 @@ const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
 const powerpack_1 = require("../utils/powerpack");
+const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -102,10 +103,25 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
 }
 async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
-        const taskResults = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions);
-        return Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+        await (0, tasks_execution_hooks_1.runPreTasksExecution)({
+            workspaceRoot: workspace_root_1.workspaceRoot,
+            nxJsonConfiguration: nxJson,
+        });
+        const taskResults = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, {
+            ...nxArgs,
+            skipNxCache: nxArgs.skipNxCache ||
+                process.env.NX_SKIP_NX_CACHE === 'true' ||
+                process.env.NX_DISABLE_NX_CACHE === 'true',
+        }, overrides, initiatingProject, extraTargetDependencies, extraOptions);
+        const result = Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
             ? 1
             : 0;
+        await (0, tasks_execution_hooks_1.runPostTasksExecution)({
+            taskResults,
+            workspaceRoot: workspace_root_1.workspaceRoot,
+            nxJsonConfiguration: nxJson,
+        });
+        return result;
     });
     return status;
 }

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

@@ -127,7 +127,6 @@ class TaskOrchestrator {
         return res.filter((r) => r !== null);
     }
     async applyCachedResult(task) {
-        task.startTime = Date.now();
         const cachedResult = await this.cache.get(task);
         if (!cachedResult || cachedResult.code !== 0)
             return null;
@@ -137,7 +136,6 @@ class TaskOrchestrator {
         if (shouldCopyOutputsFromCache) {
             await this.cache.copyFilesFromCache(task.hash, cachedResult, outputs);
         }
-        task.endTime = Date.now();
         const status = cachedResult.remote
             ? 'remote-cache'
             : shouldCopyOutputsFromCache
@@ -333,10 +331,16 @@ class TaskOrchestrator {
     // endregion Single Task
     // region Lifecycle
     async preRunSteps(tasks, metadata) {
+        const now = Date.now();
+        for (const task of tasks) {
+            task.startTime = now;
+        }
         await this.options.lifeCycle.startTasks(tasks, metadata);
     }
     async postRunSteps(tasks, results, doNotSkipCache, { groupId }) {
+        const now = Date.now();
         for (const task of tasks) {
+            task.endTime = now;
             await this.recordOutputsHash(task);
         }
         if (doNotSkipCache) {