@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPluginWorkerMessage = isPluginWorkerMessage;
+exports.isPluginWorkerResult = isPluginWorkerResult;
+exports.consumeMessage = consumeMessage;
+exports.sendMessageOverSocket = sendMessageOverSocket;
+const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+// =============================================================================
+// TYPE GUARDS
+// =============================================================================
+const MESSAGE_TYPES = [
+    'load',
+    'createNodes',
+    'createDependencies',
+    'createMetadata',
+    'preTasksExecution',
+    'postTasksExecution',
+];
+const RESULT_TYPES = [
+    'loadResult',
+    'createNodesResult',
+    'createDependenciesResult',
+    'createMetadataResult',
+    'preTasksExecutionResult',
+    'postTasksExecutionResult',
+];
+function isPluginWorkerMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        MESSAGE_TYPES.includes(message.type));
+}
+function isPluginWorkerResult(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        typeof message.type === 'string' &&
+        RESULT_TYPES.includes(message.type));
+}
+// =============================================================================
+// MESSAGE HANDLING
+// =============================================================================
+/**
+ * Consumes a message and dispatches to the appropriate handler.
+ * If the handler returns a value, it's automatically wrapped in a result message
+ * with the correct type and transaction ID.
+ *
+ * Handlers return just the result payload - the infrastructure handles wrapping.
+ */
+async function consumeMessage(socket, raw, handlers) {
+    const message = raw;
+    const type = message.type;
+    const handler = handlers[type];
+    // Type widening for dynamic dispatch - safe because types guarantee
+    // message.type always indexes into the matching handler
+    const resultPayload = await handler(message.payload);
+    if (resultPayload !== undefined && resultPayload !== null) {
+        sendMessageOverSocket(socket, {
+            type: `${type}Result`,
+            payload: resultPayload,
+            tx: message.tx,
+        });
+    }
+}
+/**
+ * Sends a message over the socket with proper formatting.
+ */
+function sendMessageOverSocket(socket, message) {
+    socket.write(JSON.stringify(message) + consume_messages_from_socket_1.MESSAGE_END_SEQ);
+}

package/src/project-graph/plugins/isolation/plugin-lifecycle-manager.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Phase configuration - single source of truth.
+ * Key order defines phase execution order.
+ * Hooks within each phase can execute in any order.
+ */
+declare const HOOKS_BY_PHASE: {
+    readonly graph: readonly ["createNodes", "createDependencies", "createMetadata"];
+    readonly 'pre-task': readonly ["preTasksExecution"];
+    readonly 'post-task': readonly ["postTasksExecution"];
+};
+export type Phase = keyof typeof HOOKS_BY_PHASE;
+export type Hook = (typeof HOOKS_BY_PHASE)[Phase][number];
+/**
+ * Manages the lifecycle of an isolated plugin worker.
+ *
+ * Tracks phase entry/exit to determine when a worker can safely shut down.
+ * A "phase session" starts when a caller enters the first registered hook
+ * of a phase and ends when they exit the last registered hook.
+ *
+ * Shutdown occurs when:
+ * 1. All phase sessions complete (ref count reaches 0)
+ * 2. No later phases have registered hooks
+ */
+export declare class PluginLifecycleManager {
+    /** Phases where this plugin has at least one registered hook */
+    private readonly registeredPhases;
+    /** Number of active "phase sessions" (callers between first and last hook) */
+    private readonly phaseSessionCount;
+    /** Ordered list of registered phases (derived from HOOKS_BY_PHASE key order, narrowed to registered phases) */
+    private readonly registeredPhaseOrder;
+    constructor(registeredHooks: Iterable<Hook>);
+    wrapHook<TArgs extends unknown[], TReturn>(hook: Hook, fn: (...args: TArgs) => Promise<TReturn>, shutdown: () => Promise<void> | void): (...args: TArgs) => Promise<TReturn>;
+    /**
+     * Called when entering a hook. Increments phase session count if this
+     * is the first registered hook in the phase.
+     */
+    enterHook(hook: Hook): void;
+    /**
+     * Called when exiting a hook. Decrements phase session count if this
+     * is the last registered hook in the phase.
+     *
+     * @returns true if the worker should shut down, false otherwise
+     */
+    exitHook(hook: Hook): boolean;
+    /**
+     * Returns true if the worker should shut down immediately after construction.
+     * This happens when the plugin has no graph-phase hooks, meaning it won't
+     * be needed until task execution time (pre-task or post-task).
+     */
+    shouldShutdownImmediately(): boolean;
+    /**
+     * Returns true if the plugin has any hooks in the given phase.
+     */
+    hasHooksInPhase(phase: Phase): boolean;
+    /**
+     * Returns true if this is the last phase with registered hooks.
+     */
+    isLastRegisteredPhase(phase: Phase): boolean;
+    /**
+     * Returns the current session count for a phase. Useful for testing.
+     */
+    getPhaseRefCount(phase: Phase): number;
+}
+export {};
+//# sourceMappingURL=plugin-lifecycle-manager.d.ts.map

package/src/project-graph/plugins/isolation/plugin-lifecycle-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-lifecycle-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/plugin-lifecycle-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,QAAA,MAAM,cAAc;;;;CAIV,CAAC;AAEX,MAAM,MAAM,KAAK,GAAG,MAAM,OAAO,cAAc,CAAC;AAChD,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;AAgB1D;;;;;;;;;;GAUG;AACH,qBAAa,sBAAsB;IACjC,gEAAgE;IAChE,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsC;IAEvE,8EAA8E;IAC9E,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAsC;IAExE,+GAA+G;IAC/G,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAe;gBAExC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC;IAqB3C,QAAQ,CAAC,KAAK,SAAS,OAAO,EAAE,EAAE,OAAO,EACvC,IAAI,EAAE,IAAI,EACV,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC,EACxC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,GACnC,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,OAAO,CAAC;IAcvC;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAmB3B;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAgC7B;;;;OAIG;IACH,yBAAyB,IAAI,OAAO;IAIpC;;OAEG;IACH,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAItC;;OAEG;IACH,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAQ5C;;OAEG;IACH,gBAAgB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;CAGvC"}

package/src/project-graph/plugins/isolation/plugin-lifecycle-manager.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginLifecycleManager = void 0;
+/**
+ * Phase configuration - single source of truth.
+ * Key order defines phase execution order.
+ * Hooks within each phase can execute in any order.
+ */
+const HOOKS_BY_PHASE = {
+    graph: ['createNodes', 'createDependencies', 'createMetadata'],
+    'pre-task': ['preTasksExecution'],
+    'post-task': ['postTasksExecution'],
+};
+const PHASE_BY_HOOK = Object.entries(HOOKS_BY_PHASE).reduce((acc, [phase, hooks]) => {
+    for (const hook of hooks) {
+        acc[hook] = phase;
+    }
+    return acc;
+}, {});
+const PHASE_ORDER = keys(HOOKS_BY_PHASE);
+/**
+ * Manages the lifecycle of an isolated plugin worker.
+ *
+ * Tracks phase entry/exit to determine when a worker can safely shut down.
+ * A "phase session" starts when a caller enters the first registered hook
+ * of a phase and ends when they exit the last registered hook.
+ *
+ * Shutdown occurs when:
+ * 1. All phase sessions complete (ref count reaches 0)
+ * 2. No later phases have registered hooks
+ */
+class PluginLifecycleManager {
+    constructor(registeredHooks) {
+        /** Phases where this plugin has at least one registered hook */
+        this.registeredPhases = {};
+        /** Number of active "phase sessions" (callers between first and last hook) */
+        this.phaseSessionCount = {};
+        /** Ordered list of registered phases (derived from HOOKS_BY_PHASE key order, narrowed to registered phases) */
+        this.registeredPhaseOrder = [];
+        const registered = new Set(registeredHooks);
+        // Determine which phases are registered and find first/last hooks per phase
+        this.registeredPhases = {};
+        for (const phase of PHASE_ORDER) {
+            const hooksInPhase = HOOKS_BY_PHASE[phase].filter((hook) => registered.has(hook));
+            if (hooksInPhase.length > 0) {
+                this.registeredPhases[phase] = hooksInPhase;
+                this.registeredPhaseOrder.push(phase);
+            }
+        }
+        // Initialize session counts to 0
+        for (const phase of this.registeredPhaseOrder) {
+            this.phaseSessionCount[phase] = 0;
+        }
+    }
+    wrapHook(hook, fn, shutdown) {
+        return async (...args) => {
+            this.enterHook(hook);
+            try {
+                return await fn(...args);
+            }
+            finally {
+                const shouldShutdown = this.exitHook(hook);
+                if (shouldShutdown) {
+                    await shutdown();
+                }
+            }
+        };
+    }
+    /**
+     * Called when entering a hook. Increments phase session count if this
+     * is the first registered hook in the phase.
+     */
+    enterHook(hook) {
+        const phase = PHASE_BY_HOOK[hook];
+        const phaseHooks = this.registeredPhases[phase];
+        if (!phaseHooks || !phaseHooks.includes(hook)) {
+            throw new Error(`Hook "${hook}" is not registered for this plugin. Registered phases: ${this.registeredPhaseOrder.join(', ')}`);
+        }
+        // If this is the first hook registered by this plugin in the phase, increment session count
+        const firstHook = phaseHooks[0];
+        if (hook === firstHook) {
+            this.phaseSessionCount[phase] ??= 0;
+            this.phaseSessionCount[phase]++;
+        }
+    }
+    /**
+     * Called when exiting a hook. Decrements phase session count if this
+     * is the last registered hook in the phase.
+     *
+     * @returns true if the worker should shut down, false otherwise
+     */
+    exitHook(hook) {
+        const phase = PHASE_BY_HOOK[hook];
+        const phaseHooks = this.registeredPhases[phase];
+        if (!phaseHooks) {
+            throw new Error(`Hook "${hook}" is not registered for this plugin. Registered phases: ${this.registeredPhaseOrder.join(', ')}`);
+        }
+        // Only process shutdown logic on last hook (exiting the phase)
+        if (hook !== phaseHooks[phaseHooks.length - 1]) {
+            return false;
+        }
+        // Decrement session count
+        const count = this.phaseSessionCount[phase] ?? 0;
+        if (count === 0) {
+            throw new Error(`Mismatched exitHook call for phase "${phase}". No active sessions.`);
+        }
+        const newCount = count - 1;
+        this.phaseSessionCount[phase] = newCount;
+        // Can only shut down if no more active sessions in this phase
+        if (newCount > 0)
+            return false;
+        // Can only shut down if this is the last registered phase
+        return this.isLastRegisteredPhase(phase);
+    }
+    /**
+     * Returns true if the worker should shut down immediately after construction.
+     * This happens when the plugin has no graph-phase hooks, meaning it won't
+     * be needed until task execution time (pre-task or post-task).
+     */
+    shouldShutdownImmediately() {
+        return !this.registeredPhases['graph'];
+    }
+    /**
+     * Returns true if the plugin has any hooks in the given phase.
+     */
+    hasHooksInPhase(phase) {
+        return !!this.registeredPhases[phase];
+    }
+    /**
+     * Returns true if this is the last phase with registered hooks.
+     */
+    isLastRegisteredPhase(phase) {
+        const phaseIndex = this.registeredPhaseOrder.indexOf(phase);
+        if (phaseIndex === -1) {
+            throw new Error(`Phase "${phase}" is not registered for this plugin.`);
+        }
+        return phaseIndex === this.registeredPhaseOrder.length - 1;
+    }
+    /**
+     * Returns the current session count for a phase. Useful for testing.
+     */
+    getPhaseRefCount(phase) {
+        return this.phaseSessionCount[phase] ?? 0;
+    }
+}
+exports.PluginLifecycleManager = PluginLifecycleManager;
+function keys(obj) {
+    return Object.keys(obj);
+}

package/src/project-graph/plugins/isolation/plugin-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin-worker.d.ts.map

package/src/project-graph/plugins/isolation/plugin-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-worker.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/plugin-worker.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_perf_hooks_1 = require("node:perf_hooks");
+node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- start`);
+const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const logger_1 = require("../../../utils/logger");
+const serializable_error_1 = require("../../../utils/serializable-error");
+const messaging_1 = require("./messaging");
+const fs_1 = require("fs");
+const net_1 = require("net");
+const environment = process.env;
+if (environment.NX_PERF_LOGGING === 'true') {
+    require('../../../utils/perf-logging');
+}
+node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- end`);
+node_perf_hooks_1.performance.measure(`plugin worker ${process.pid} code loading`, `plugin worker ${process.pid} code loading -- start`, `plugin worker ${process.pid} code loading -- end`);
+global.NX_GRAPH_CREATION = true;
+global.NX_PLUGIN_WORKER = true;
+let plugin;
+const socketPath = process.argv[2];
+const expectedPluginName = process.argv[3];
+let connectErrorTimeout = setErrorTimeout(5000, `The plugin worker for ${expectedPluginName} is exiting as it was not connected to within 5 seconds. ` +
+    'Plugin workers expect to receive a socket connection from the parent process shortly after being started. ' +
+    'If you are seeing this issue, please report it to the Nx team at https://github.com/nrwl/nx/issues.');
+const server = (0, net_1.createServer)((socket) => {
+    connectErrorTimeout?.clear();
+    logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) connected`);
+    // This handles cases where the host process was killed
+    // after the worker connected but before the worker was
+    // instructed to load the plugin.
+    let loadErrorTimeout = setErrorTimeout(10_000, `Plugin Worker for ${expectedPluginName} is exiting as it did not receive a load message within 10 seconds of connecting. ` +
+        'This likely indicates that the host process was terminated before the worker could be instructed to load the plugin. ' +
+        'If you are seeing this issue, please report it to the Nx team at https://github.com/nrwl/nx/issues.');
+    socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
+        const message = JSON.parse(raw.toString());
+        if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
+            return;
+        }
+        return (0, messaging_1.consumeMessage)(socket, message, {
+            load: async ({ plugin: pluginConfiguration, root, name, pluginPath, shouldRegisterTSTranspiler, }) => {
+                loadErrorTimeout?.clear();
+                process.chdir(root);
+                try {
+                    const { loadResolvedNxPluginAsync } = await Promise.resolve().then(() => require('../load-resolved-plugin'));
+                    // Register the ts-transpiler if we are pointing to a
+                    // plain ts file that's not part of a plugin project
+                    if (shouldRegisterTSTranspiler) {
+                        require('../transpiler').registerPluginTSTranspiler();
+                    }
+                    plugin = await loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name);
+                    logger_1.logger.verbose(`[plugin-worker] "${name}" (pid: ${process.pid}) loaded successfully`);
+                    return {
+                        name: plugin.name,
+                        include: plugin.include,
+                        exclude: plugin.exclude,
+                        createNodesPattern: plugin.createNodes?.[0],
+                        hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
+                        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,
+                    };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                    };
+                }
+            },
+            createNodes: async function createNodes({ configFiles, context }) {
+                try {
+                    const result = await plugin.createNodes[1](configFiles, context);
+                    return { result, success: true };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                    };
+                }
+            },
+            createDependencies: async function createDependencies({ context }) {
+                try {
+                    const result = await plugin.createDependencies(context);
+                    return { dependencies: result, success: true };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                    };
+                }
+            },
+            createMetadata: async function createMetadata({ graph, context }) {
+                try {
+                    const result = await plugin.createMetadata(graph, context);
+                    return { metadata: result, success: true };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                    };
+                }
+            },
+            preTasksExecution: async ({ context }) => {
+                try {
+                    const mutations = await plugin.preTasksExecution?.(context);
+                    return { success: true, mutations };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                    };
+                }
+            },
+            postTasksExecution: async ({ context }) => {
+                try {
+                    await plugin.postTasksExecution?.(context);
+                    return { success: true };
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        error: (0, serializable_error_1.createSerializableError)(e),
+                    };
+                }
+            },
+        });
+    }));
+    // There should only ever be one host -> worker connection
+    // since the worker is spawned per host process. As such,
+    // we can safely close the worker when the host disconnects.
+    socket.on('end', () => {
+        // Destroys the socket once it's fully closed.
+        socket.destroySoon();
+        // Stops accepting new connections, but existing connections are
+        // not closed immediately.
+        server.close(() => {
+            try {
+                (0, fs_1.unlinkSync)(socketPath);
+            }
+            catch (e) { }
+            process.exit(0);
+        });
+    });
+});
+server.listen(socketPath);
+logger_1.logger.verbose(`[plugin-worker] "${expectedPluginName}" (pid: ${process.pid}) listening on ${socketPath}`);
+function setErrorTimeout(timeoutMs, errorMessage) {
+    if (environment.NX_PLUGIN_NO_TIMEOUTS === 'true') {
+        return;
+    }
+    let cleared = false;
+    const timeout = setTimeout(() => {
+        if (!cleared) {
+            console.error(errorMessage);
+            process.exit(1);
+        }
+    }, timeoutMs).unref();
+    return {
+        clear: () => {
+            cleared = true;
+            clearTimeout(timeout);
+        },
+    };
+}
+const exitHandler = (exitCode) => () => {
+    server.close();
+    try {
+        (0, fs_1.unlinkSync)(socketPath);
+    }
+    catch (e) { }
+    process.exit(exitCode);
+};
+const events = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'exit'];
+events.forEach((event) => process.once(event, exitHandler(0)));
+process.once('uncaughtException', exitHandler(1));
+process.once('unhandledRejection', exitHandler(1));

package/src/project-graph/plugins/load-resolved-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { PluginConfiguration } from '../../config/nx-json';
+import { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function loadResolvedNxPluginAsync(pluginConfiguration: PluginConfiguration, pluginPath: string, name: string, index?: number): Promise<LoadedNxPlugin>;
+//# sourceMappingURL=load-resolved-plugin.d.ts.map

package/src/project-graph/plugins/load-resolved-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-resolved-plugin.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/plugins/load-resolved-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,wBAAsB,yBAAyB,CAC7C,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,2BAKf"}

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResolvedNxPluginAsync = loadResolvedNxPluginAsync;
+const loaded_nx_plugin_1 = require("./loaded-nx-plugin");
+async function loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name, index) {
+    const plugin = await importPluginModule(pluginPath);
+    plugin.name ??= name;
+    return new loaded_nx_plugin_1.LoadedNxPlugin(plugin, pluginConfiguration, index);
+}
+async function importPluginModule(pluginPath) {
+    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
+    if (m.default &&
+        ('createNodes' in m.default ||
+            'createNodesV2' 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

@@ -0,0 +1,26 @@
+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, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
+/**
+ * NOTE: Avoid using `import type` with this class. It causes issues with
+ * jest's module resolution when running tests in projects that import
+ * the devkit-internals
+ */
+export declare class LoadedNxPlugin {
+    readonly index?: number;
+    readonly name: string;
+    readonly createNodes?: [
+        filePattern: string,
+        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
+    ];
+    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, index?: number);
+}
+//# sourceMappingURL=loaded-nx-plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loaded-nx-plugin.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/plugins/loaded-nx-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAKhE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,KAAK,EACV,yBAAyB,EACzB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,UAAU,EACV,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EACjB,MAAM,cAAc,CAAC;AAItB;;;;GAIG;AACH,qBAAa,cAAc;aAkCP,KAAK,CAAC,EAAE,MAAM;IAjChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE;QACrB,WAAW,EAAE,MAAM;QAGnB,EAAE,EAAE,CACF,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,oBAAoB,KAC1B,OAAO,CACV,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAC1E;KACF,CAAC;IACF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAC5B,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,yBAAyB,EAAE,CAAC,CAAC;IAC1C,QAAQ,CAAC,cAAc,CAAC,EAAE,CACxB,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,qBAAqB,KAC3B,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC/B,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAC3B,OAAO,EAAE,wBAAwB,KAC9B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;IAChC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAC5B,OAAO,EAAE,yBAAyB,KAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IAEnB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;gBAG1B,MAAM,EAAE,UAAU,EAClB,gBAAgB,EAAE,mBAAmB,EACrB,KAAK,CAAC,EAAE,MAAM;CAwFjC"}

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadedNxPlugin = void 0;
+const error_types_1 = require("../error-types");
+const enabled_1 = require("./isolation/enabled");
+const client_1 = require("../../daemon/client/client");
+/**
+ * NOTE: Avoid using `import type` with this class. It causes issues with
+ * jest's module resolution when running tests in projects that import
+ * the devkit-internals
+ */
+class LoadedNxPlugin {
+    constructor(plugin, pluginDefinition, index) {
+        this.index = index;
+        this.name = plugin.name;
+        if (typeof pluginDefinition !== 'string') {
+            this.options = pluginDefinition.options;
+            this.include = pluginDefinition.include;
+            this.exclude = pluginDefinition.exclude;
+        }
+        const createNodesV2Impl = plugin.createNodesV2 ?? plugin.createNodes;
+        if (createNodesV2Impl) {
+            this.createNodes = [
+                createNodesV2Impl[0],
+                async (configFiles, context) => {
+                    const result = await createNodesV2Impl[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
+            ];
+        }
+        /**
+         * Wraps the plugin-provided createNodes function to provide performance
+         * measurement and error handling.
+         */
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
+        }
+        if (plugin.createMetadata) {
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
+        if (plugin.preTasksExecution) {
+            this.preTasksExecution = async (context) => {
+                const updates = {};
+                let originalEnv = process.env;
+                if ((0, enabled_1.isIsolationEnabled)() || (0, client_1.isDaemonEnabled)()) {
+                    process.env = new Proxy(originalEnv, {
+                        set: (target, key, value) => {
+                            target[key] = value;
+                            updates[key] = value;
+                            return true;
+                        },
+                    });
+                }
+                await plugin.preTasksExecution(this.options, context);
+                // This doesn't revert env changes, as the proxy still updates
+                // originalEnv, rather it removes the proxy.
+                process.env = originalEnv;
+                return updates;
+            };
+        }
+        if (plugin.postTasksExecution) {
+            this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
+        }
+    }
+}
+exports.LoadedNxPlugin = LoadedNxPlugin;