nx 20.4.0-canary.20250124-45847a6 → 20.4.0-rc.0

package/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{69552:()=>{}},s=>{var e;e=69552,s(s.s=e)}]);
+"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{6395:()=>{}},s=>{var e;e=6395,s(s.s=e)}]);

package/src/daemon/client/client.d.ts

@@ -5,6 +5,7 @@ import { Task, TaskGraph } from '../../config/task-graph';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
 import { NxWorkspaceFiles, TaskRun, TaskTarget } from '../../native';
 import type { FlushSyncGeneratorChangesResult, SyncGeneratorRunResult } from '../../utils/sync-generators';
+import { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
 export type UnregisterCallback = () => void;
 export type ChangedFile = {
     path: string;
@@ -60,6 +61,8 @@ export declare class DaemonClient {
         taskGenerators: string[];
     }>;
     updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
+    runPreTasksExecution(context: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
+    runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;
     isServerAvailable(): Promise<boolean>;
     private sendToDaemonViaQueue;
     private setUpConnection;

package/src/daemon/client/client.js

@@ -31,6 +31,7 @@ const get_registered_sync_generators_1 = require("../message-types/get-registere
 const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
 const delayed_spinner_1 = require("../../utils/delayed-spinner");
+const run_tasks_execution_hooks_1 = require("../message-types/run-tasks-execution-hooks");
 const DAEMON_ENV_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -292,6 +293,20 @@ class DaemonClient {
         };
         return this.sendToDaemonViaQueue(message);
     }
+    async runPreTasksExecution(context) {
+        const message = {
+            type: run_tasks_execution_hooks_1.PRE_TASKS_EXECUTION,
+            context,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    async runPostTasksExecution(context) {
+        const message = {
+            type: run_tasks_execution_hooks_1.POST_TASKS_EXECUTION,
+            context,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     async isServerAvailable() {
         return new Promise((resolve) => {
             try {

package/src/daemon/message-types/run-tasks-execution-hooks.d.ts

@@ -0,0 +1,13 @@
+import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins';
+export declare const PRE_TASKS_EXECUTION: "PRE_TASKS_EXECUTION";
+export declare const POST_TASKS_EXECUTION: "POST_TASKS_EXECUTION";
+export type HandlePreTasksExecutionMessage = {
+    type: typeof PRE_TASKS_EXECUTION;
+    context: PreTasksExecutionContext;
+};
+export type HandlePostTasksExecutionMessage = {
+    type: typeof POST_TASKS_EXECUTION;
+    context: PostTasksExecutionContext;
+};
+export declare function isHandlePreTasksExecutionMessage(message: unknown): message is HandlePreTasksExecutionMessage;
+export declare function isHandlePostTasksExecutionMessage(message: unknown): message is HandlePostTasksExecutionMessage;

package/src/daemon/message-types/run-tasks-execution-hooks.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST_TASKS_EXECUTION = exports.PRE_TASKS_EXECUTION = void 0;
+exports.isHandlePreTasksExecutionMessage = isHandlePreTasksExecutionMessage;
+exports.isHandlePostTasksExecutionMessage = isHandlePostTasksExecutionMessage;
+exports.PRE_TASKS_EXECUTION = 'PRE_TASKS_EXECUTION';
+exports.POST_TASKS_EXECUTION = 'POST_TASKS_EXECUTION';
+function isHandlePreTasksExecutionMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.PRE_TASKS_EXECUTION);
+}
+function isHandlePostTasksExecutionMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.POST_TASKS_EXECUTION);
+}

package/src/daemon/server/handle-tasks-execution-hooks.d.ts

@@ -0,0 +1,19 @@
+import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+export declare function handleRunPreTasksExecution(context: PreTasksExecutionContext): Promise<{
+    response: string;
+    description: string;
+    error?: undefined;
+} | {
+    error: any;
+    description: string;
+    response?: undefined;
+}>;
+export declare function handleRunPostTasksExecution(context: PostTasksExecutionContext): Promise<{
+    response: string;
+    description: string;
+    error?: undefined;
+} | {
+    error: any;
+    description: string;
+    response?: undefined;
+}>;

package/src/daemon/server/handle-tasks-execution-hooks.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRunPreTasksExecution = handleRunPreTasksExecution;
+exports.handleRunPostTasksExecution = handleRunPostTasksExecution;
+const tasks_execution_hooks_1 = require("../../project-graph/plugins/tasks-execution-hooks");
+async function handleRunPreTasksExecution(context) {
+    try {
+        const envs = await (0, tasks_execution_hooks_1.runPreTasksExecution)(context);
+        return {
+            response: JSON.stringify(envs),
+            description: 'handleRunPreTasksExecution',
+        };
+    }
+    catch (e) {
+        return {
+            error: e,
+            description: `Error when running preTasksExecution.`,
+        };
+    }
+}
+async function handleRunPostTasksExecution(context) {
+    try {
+        await (0, tasks_execution_hooks_1.runPostTasksExecution)(context);
+        return {
+            response: 'true',
+            description: 'handleRunPostTasksExecution',
+        };
+    }
+    catch (e) {
+        return {
+            error: e,
+            description: `Error when running postTasksExecution.`,
+        };
+    }
+}

package/src/daemon/server/server.js

@@ -50,6 +50,8 @@ const update_workspace_context_1 = require("../message-types/update-workspace-co
 const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
 const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
 const handle_flush_sync_generator_changes_to_disk_1 = require("./handle-flush-sync-generator-changes-to-disk");
+const run_tasks_execution_hooks_1 = require("../message-types/run-tasks-execution-hooks");
+const handle_tasks_execution_hooks_1 = require("./handle-tasks-execution-hooks");
 let performanceObserver;
 let workspaceWatcherError;
 let outputsWatcherError;
@@ -163,6 +165,12 @@ async function handleMessage(socket, data) {
     else if ((0, update_workspace_context_1.isHandleUpdateWorkspaceContextMessage)(payload)) {
         await handleResult(socket, update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT, () => (0, handle_update_workspace_context_1.handleUpdateWorkspaceContext)(payload.createdFiles, payload.updatedFiles, payload.deletedFiles));
     }
+    else if ((0, run_tasks_execution_hooks_1.isHandlePreTasksExecutionMessage)(payload)) {
+        await handleResult(socket, run_tasks_execution_hooks_1.PRE_TASKS_EXECUTION, () => (0, handle_tasks_execution_hooks_1.handleRunPreTasksExecution)(payload.context));
+    }
+    else if ((0, run_tasks_execution_hooks_1.isHandlePostTasksExecutionMessage)(payload)) {
+        await handleResult(socket, run_tasks_execution_hooks_1.POST_TASKS_EXECUTION, () => (0, handle_tasks_execution_hooks_1.handleRunPostTasksExecution)(payload.context));
+    }
     else {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
     }

package/src/devkit-exports.d.ts

@@ -15,13 +15,17 @@ export type { WorkspaceJsonConfiguration, ProjectsConfigurations, TargetDependen
  */
 export type { Generator, GeneratorCallback, PromiseExecutor, AsyncIteratorExecutor, Executor, ExecutorContext, TaskGraphExecutor, GeneratorsJson, ExecutorsJson, MigrationsJson, CustomHasher, HasherContext, } from './config/misc-interfaces';
 export { workspaceLayout } from './config/configuration';
-export type { NxPlugin, NxPluginV2, CreateNodes, CreateNodesFunction, CreateNodesResult, CreateNodesContext, CreateNodesContextV2, CreateNodesFunctionV2, CreateNodesResultV2, CreateNodesV2, CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, ProjectsMetadata, } from './project-graph/plugins';
+export type { NxPlugin, NxPluginV2, CreateNodes, CreateNodesFunction, CreateNodesResult, CreateNodesContext, CreateNodesContextV2, CreateNodesFunctionV2, CreateNodesResultV2, CreateNodesV2, CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, ProjectsMetadata, PreTasksExecution, PreTasksExecutionContext, PostTasksExecution, PostTasksExecutionContext, } from './project-graph/plugins';
 export { AggregateCreateNodesError } from './project-graph/error-types';
 export { createNodesFromFiles } from './project-graph/plugins';
 /**
- * @category Workspace
+ * @category Tasks
  */
 export type { Task, TaskGraph } from './config/task-graph';
+/**
+ * @category Tasks
+ */
+export type { TaskResult, TaskResults } from './tasks-runner/life-cycle';
 /**
  * @category Workspace
  */

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -191,10 +191,7 @@ class TargetProjectLocator {
     }
     findDependencyInWorkspaceProjects(dep) {
         this.packageEntryPointsToProjectMap ??= (0, packages_1.getPackageEntryPointsToProjectMap)(this.nodes);
-        return (this.packageEntryPointsToProjectMap[dep]?.name ??
-            // if the package exports do not include ".", look for subpath exports
-            Object.entries(this.packageEntryPointsToProjectMap).find(([entryPoint]) => dep.startsWith(`${entryPoint}/`))?.[1]?.name ??
-            null);
+        return this.packageEntryPointsToProjectMap[dep]?.name ?? null;
     }
     resolveImportWithTypescript(normalizedImportExpr, filePath) {
         let resolvedModule;

package/src/plugins/js/utils/packages.js

@@ -10,28 +10,14 @@ function getPackageEntryPointsToProjectMap(projects) {
             continue;
         }
         const { packageName, packageExports } = metadata.js;
-        if (!packageExports ||
-            typeof packageExports === 'string' ||
-            !Object.keys(packageExports).length) {
+        if (!packageExports || typeof packageExports === 'string') {
             // no `exports` or it points to a file, which would be the equivalent of
             // an '.' export, in which case the package name is the entry point
             result[packageName] = project;
         }
         else {
             for (const entryPoint of Object.keys(packageExports)) {
-                // if entrypoint begins with '.', it is a relative subpath export
-                // otherwise, it is a conditional export
-                // https://nodejs.org/api/packages.html#conditional-exports
-                if (entryPoint.startsWith('.')) {
-                    result[(0, posix_1.join)(packageName, entryPoint)] = project;
-                }
-                else {
-                    result[packageName] = project;
-                }
-            }
-            // if there was no '.' entrypoint, ensure the package name is matched with the project
-            if (!result[packageName]) {
-                result[packageName] = project;
+                result[(0, posix_1.join)(packageName, entryPoint)] = project;
             }
         }
     }

package/src/project-graph/plugins/get-plugins.js

@@ -7,11 +7,11 @@ const node_path_1 = require("node:path");
 const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
 const file_hasher_1 = require("../../hasher/file-hasher");
-const native_1 = require("../../native");
 const workspace_root_1 = require("../../utils/workspace-root");
 const isolation_1 = require("./isolation");
 const in_process_loader_1 = require("./in-process-loader");
 const transpiler_1 = require("./transpiler");
+const enabled_1 = require("./isolation/enabled");
 /**
  * Stuff for specified NX Plugins.
  */
@@ -73,22 +73,7 @@ function cleanupPlugins() {
 /**
  * Stuff for generic loading
  */
-function isIsolationEnabled() {
-    // Explicitly enabled, regardless of further conditions
-    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
-        return true;
-    }
-    if (
-    // Explicitly disabled
-    process.env.NX_ISOLATE_PLUGINS === 'false' ||
-        // Isolation is disabled on WASM builds currently.
-        native_1.IS_WASM) {
-        return false;
-    }
-    // Default value
-    return true;
-}
-const loadingMethod = isIsolationEnabled()
+const loadingMethod = (0, enabled_1.isIsolationEnabled)()
     ? isolation_1.loadNxPluginInIsolation
     : in_process_loader_1.loadNxPlugin;
 async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {

package/src/project-graph/plugins/isolation/enabled.d.ts

@@ -0,0 +1 @@
+export declare function isIsolationEnabled(): boolean;

package/src/project-graph/plugins/isolation/enabled.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIsolationEnabled = isIsolationEnabled;
+const native_1 = require("../../../native");
+function isIsolationEnabled() {
+    // Explicitly enabled, regardless of further conditions
+    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
+        return true;
+    }
+    if (
+    // Explicitly disabled
+    process.env.NX_ISOLATE_PLUGINS === 'false' ||
+        // Isolation is disabled on WASM builds currently.
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Default value
+    return true;
+}

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -1,9 +1,9 @@
-import { ProjectGraph } from '../../../config/project-graph';
-import { PluginConfiguration } from '../../../config/nx-json';
-import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2 } from '../public-api';
+import type { ProjectGraph } from '../../../config/project-graph';
+import type { PluginConfiguration } from '../../../config/nx-json';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, PreTasksExecutionContext, PostTasksExecutionContext } from '../public-api';
 import type { LoadedNxPlugin } from '../loaded-nx-plugin';
-import { Serializable } from 'child_process';
-import { Socket } from 'net';
+import type { Serializable } from 'child_process';
+import type { Socket } from 'net';
 export interface PluginWorkerLoadMessage {
     type: 'load';
     payload: {
@@ -24,6 +24,8 @@ export interface PluginWorkerLoadResult {
         hasCreateDependencies: boolean;
         hasProcessProjectGraph: boolean;
         hasCreateMetadata: boolean;
+        hasPreTasksExecution: boolean;
+        hasPostTasksExecution: boolean;
         success: true;
     } | {
         success: false;
@@ -89,8 +91,45 @@ export interface PluginCreateMetadataResult {
         tx: string;
     };
 }
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginCreateMetadataMessage;
-export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginCreateMetadataResult;
+export interface PluginWorkerPreTasksExecutionMessage {
+    type: 'preTasksExecution';
+    payload: {
+        tx: string;
+        context: PreTasksExecutionContext;
+    };
+}
+export interface PluginWorkerPreTasksExecutionMessageResult {
+    type: 'preTasksExecutionResult';
+    payload: {
+        tx: string;
+        success: true;
+        mutations: NodeJS.ProcessEnv;
+    } | {
+        success: false;
+        error: Error;
+        tx: string;
+    };
+}
+export interface PluginWorkerPostTasksExecutionMessage {
+    type: 'postTasksExecution';
+    payload: {
+        tx: string;
+        context: PostTasksExecutionContext;
+    };
+}
+export interface PluginWorkerPostTasksExecutionMessageResult {
+    type: 'postTasksExecutionResult';
+    payload: {
+        tx: string;
+        success: true;
+    } | {
+        success: false;
+        error: Error;
+        tx: string;
+    };
+}
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginCreateMetadataMessage | PluginWorkerPreTasksExecutionMessage | PluginWorkerPostTasksExecutionMessage;
+export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginCreateMetadataResult | PluginWorkerPreTasksExecutionMessageResult | PluginWorkerPostTasksExecutionMessageResult;
 export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
 export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
 type MaybePromise<T> = T | Promise<T>;

package/src/project-graph/plugins/isolation/messaging.js

@@ -12,9 +12,11 @@ function isPluginWorkerMessage(message) {
             'load',
             'createNodes',
             'createDependencies',
-            'processProjectGraph',
             'createMetadata',
+            'processProjectGraph',
             'shutdown',
+            'preTasksExecution',
+            'postTasksExecution',
         ].includes(message.type));
 }
 function isPluginWorkerResult(message) {
@@ -27,6 +29,8 @@ function isPluginWorkerResult(message) {
             'createDependenciesResult',
             'processProjectGraphResult',
             'createMetadataResult',
+            'preTasksExecutionResult',
+            'postTasksExecutionResult',
         ].includes(message.type));
 }
 // Takes a message and a map of handlers and calls the appropriate handler

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -131,6 +131,34 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                                 });
                             }
                             : undefined,
+                        preTasksExecution: result.hasPreTasksExecution
+                            ? (context) => {
+                                const tx = pluginName + worker.pid + ':preTasksExecution:' + txId++;
+                                return registerPendingPromise(tx, pending, () => {
+                                    (0, messaging_1.sendMessageOverSocket)(socket, {
+                                        type: 'preTasksExecution',
+                                        payload: { tx, context },
+                                    });
+                                }, {
+                                    plugin: pluginName,
+                                    operation: 'preTasksExecution',
+                                });
+                            }
+                            : undefined,
+                        postTasksExecution: result.hasPostTasksExecution
+                            ? (context) => {
+                                const tx = pluginName + worker.pid + ':postTasksExecution:' + txId++;
+                                return registerPendingPromise(tx, pending, () => {
+                                    (0, messaging_1.sendMessageOverSocket)(socket, {
+                                        type: 'postTasksExecution',
+                                        payload: { tx, context },
+                                    });
+                                }, {
+                                    plugin: pluginName,
+                                    operation: 'postTasksExecution',
+                                });
+                            }
+                            : undefined,
                     });
                 }
                 else if (result.success === false) {
@@ -164,6 +192,24 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                     rejector(result.error);
                 }
             },
+            preTasksExecutionResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver(result.mutations);
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
+            postTasksExecutionResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver();
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
         });
     };
 }

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -51,6 +51,8 @@ const server = (0, net_1.createServer)((socket) => {
                             hasProcessProjectGraph: 'processProjectGraph' in plugin &&
                                 !!plugin.processProjectGraph,
                             hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
+                            hasPreTasksExecution: 'preTasksExecution' in plugin && !!plugin.preTasksExecution,
+                            hasPostTasksExecution: 'postTasksExecution' in plugin && !!plugin.postTasksExecution,
                             success: true,
                         },
                     };
@@ -122,6 +124,44 @@ const server = (0, net_1.createServer)((socket) => {
                     };
                 }
             },
+            preTasksExecution: async ({ tx, context }) => {
+                try {
+                    const mutations = await plugin.preTasksExecution?.(context);
+                    return {
+                        type: 'preTasksExecutionResult',
+                        payload: { success: true, tx, mutations },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'preTasksExecutionResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
+            postTasksExecution: async ({ tx, context }) => {
+                try {
+                    await plugin.postTasksExecution?.(context);
+                    return {
+                        type: 'postTasksExecutionResult',
+                        payload: { success: true, tx },
+                    };
+                }
+                catch (e) {
+                    return {
+                        type: 'postTasksExecutionResult',
+                        payload: {
+                            success: false,
+                            error: (0, serializable_error_1.createSerializableError)(e),
+                            tx,
+                        },
+                    };
+                }
+            },
         });
     }));
     // There should only ever be one host -> worker connection

package/src/project-graph/plugins/load-resolved-plugin.js

@@ -12,7 +12,10 @@ async function importPluginModule(pluginPath) {
     if (m.default &&
         ('createNodes' in m.default ||
             'createNodesV2' in m.default ||
-            'createDependencies' in m.default)) {
+            'createDependencies' in m.default ||
+            'createMetadata' in m.default ||
+            'preTasksExecution' in m.default ||
+            'postTasksExecution' in m.default)) {
         return m.default;
     }
     return m;

package/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -1,7 +1,7 @@
 import type { ProjectGraph } from '../../config/project-graph';
 import type { PluginConfiguration } from '../../config/nx-json';
 import type { RawProjectGraphDependency } from '../project-graph-builder';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, ProjectsMetadata } from './public-api';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
 export declare class LoadedNxPlugin {
     readonly name: string;
     readonly createNodes?: [
@@ -10,12 +10,10 @@ export declare class LoadedNxPlugin {
     ];
     readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
     readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
+    readonly preTasksExecution?: (context: PreTasksExecutionContext) => Promise<NodeJS.ProcessEnv>;
+    readonly postTasksExecution?: (context: PostTasksExecutionContext) => Promise<void>;
     readonly options?: unknown;
     readonly include?: string[];
     readonly exclude?: string[];
     constructor(plugin: NxPluginV2, pluginDefinition: PluginConfiguration);
 }
-export type CreateNodesResultWithContext = CreateNodesResult & {
-    file: string;
-    pluginName: string;
-};

package/src/project-graph/plugins/loaded-nx-plugin.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadedNxPlugin = void 0;
 const error_types_1 = require("../error-types");
 const utils_1 = require("./utils");
+const enabled_1 = require("./isolation/enabled");
+const client_1 = require("../../daemon/client/client");
 class LoadedNxPlugin {
     constructor(plugin, pluginDefinition) {
         this.name = plugin.name;
@@ -52,6 +54,31 @@ class LoadedNxPlugin {
         if (plugin.createMetadata) {
             this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
         }
+        if (plugin.preTasksExecution) {
+            this.preTasksExecution = async (context) => {
+                const updates = {};
+                let revokeFn;
+                if ((0, enabled_1.isIsolationEnabled)() || (0, client_1.isDaemonEnabled)()) {
+                    const { proxy, revoke } = Proxy.revocable(process.env, {
+                        set: (target, key, value) => {
+                            target[key] = value;
+                            updates[key] = value;
+                            return true;
+                        },
+                    });
+                    process.env = proxy;
+                    revokeFn = revoke;
+                }
+                await plugin.preTasksExecution(this.options, context);
+                if (revokeFn) {
+                    revokeFn();
+                }
+                return updates;
+            };
+            if (plugin.postTasksExecution) {
+                this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
+            }
+        }
     }
 }
 exports.LoadedNxPlugin = LoadedNxPlugin;

package/src/project-graph/plugins/public-api.d.ts

@@ -1,7 +1,8 @@
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { NxJsonConfiguration } from '../../config/nx-json';
-import { RawProjectGraphDependency } from '../project-graph-builder';
+import type { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+import type { TaskResults } from '../../tasks-runner/life-cycle';
 /**
  * Context for {@link CreateNodesFunction}
  */
@@ -96,7 +97,7 @@ export type CreateMetadataContext = {
 export type ProjectsMetadata = Record<string, Pick<ProjectConfiguration, 'metadata'>>;
 export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | undefined, context: CreateMetadataContext) => ProjectsMetadata | Promise<ProjectsMetadata>;
 /**
- * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
+ * A plugin which enhances the behavior of Nx
  */
 export type NxPluginV2<TOptions = unknown> = {
     name: string;
@@ -122,8 +123,27 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a function to create metadata for the {@link ProjectGraph}
      */
     createMetadata?: CreateMetadata<TOptions>;
+    /**
+     * Provides a function to run before the Nx runs tasks
+     */
+    preTasksExecution?: PreTasksExecution<TOptions>;
+    /**
+     * Provides a function to run after the Nx runs tasks
+     */
+    postTasksExecution?: PostTasksExecution<TOptions>;
+};
+export type PreTasksExecutionContext = {
+    readonly workspaceRoot: string;
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+};
+export type PostTasksExecutionContext = {
+    readonly workspaceRoot: string;
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly taskResults: TaskResults;
 };
+export type PreTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PreTasksExecutionContext) => void | Promise<void>;
+export type PostTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PostTasksExecutionContext) => void | Promise<void>;
 /**
- * A plugin for Nx
+ * A plugin which enhances the behavior of Nx
  */
 export type NxPlugin = NxPluginV2;

package/src/project-graph/plugins/tasks-execution-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { PostTasksExecutionContext, PreTasksExecutionContext } from './public-api';
+export declare function runPreTasksExecution(pluginContext: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
+export declare function runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;