nx 18.1.0-canary.20240224-26b266f → 18.1.0-canary.20240228-4d13753

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.1.0-canary.20240224-26b266f",
+  "version": "18.1.0-canary.20240228-4d13753",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -66,7 +66,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "18.1.0-canary.20240224-26b266f"
+    "@nrwl/tao": "18.1.0-canary.20240228-4d13753"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-darwin-arm64": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-linux-x64-gnu": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-linux-x64-musl": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-win32-x64-msvc": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-linux-arm64-gnu": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-linux-arm64-musl": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-linux-arm-gnueabihf": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-win32-arm64-msvc": "18.1.0-canary.20240224-26b266f",
-    "@nx/nx-freebsd-x64": "18.1.0-canary.20240224-26b266f"
+    "@nx/nx-darwin-x64": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-darwin-arm64": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-linux-x64-gnu": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-linux-x64-musl": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-win32-x64-msvc": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-linux-arm64-gnu": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-linux-arm64-musl": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-linux-arm-gnueabihf": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-win32-arm64-msvc": "18.1.0-canary.20240228-4d13753",
+    "@nx/nx-freebsd-x64": "18.1.0-canary.20240228-4d13753"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/project-graph/build-project-graph.js

@@ -9,6 +9,7 @@ const nx_deps_cache_1 = require("./nx-deps-cache");
 const implicit_project_dependencies_1 = require("./utils/implicit-project-dependencies");
 const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
 const internal_api_1 = require("./plugins/internal-api");
+const utils_1 = require("./plugins/utils");
 const typescript_1 = require("../plugins/js/utils/typescript");
 const fileutils_1 = require("../utils/fileutils");
 const project_graph_builder_1 = require("./project-graph-builder");
@@ -145,7 +146,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph) {
     let graph = initProjectGraph;
     for (const plugin of plugins) {
         try {
-            if ((0, internal_api_1.isNxPluginV1)(plugin) &&
+            if ((0, utils_1.isNxPluginV1)(plugin) &&
                 plugin.processProjectGraph &&
                 !plugin.createDependencies) {
                 output_1.output.warn({
@@ -183,7 +184,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph) {
         }
     }
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
-    const createDependencyPlugins = plugins.filter((plugin) => (0, internal_api_1.isNxPluginV2)(plugin) && plugin.createDependencies);
+    const createDependencyPlugins = plugins.filter((plugin) => (0, utils_1.isNxPluginV2)(plugin) && plugin.createDependencies);
     await Promise.all(createDependencyPlugins.map(async (plugin) => {
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
         // Set this globally to allow plugins to know if they are being called from the project graph creation

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

@@ -1,6 +1,6 @@
 import { PluginConfiguration } from '../../config/nx-json';
 import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import { CreateNodesContext, CreateNodesResult, NxPlugin, NxPluginV2 } from './public-api';
+import { CreateNodesContext, CreateNodesResult, NxPluginV2 } from './public-api';
 export type CreateNodesResultWithContext = CreateNodesResult & {
     file: string;
     pluginName: string;
@@ -15,7 +15,4 @@ export type RemotePlugin = Omit<NormalizedPlugin, 'createNodes'> & {
 export declare const nxPluginCache: Map<unknown, RemotePlugin>;
 export declare function loadNxPlugins(plugins: PluginConfiguration[], root?: string): Promise<RemotePlugin[]>;
 export declare function loadNxPlugin(plugin: PluginConfiguration, root?: string): Promise<RemotePlugin>;
-export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
-export declare function isNxPluginV1(plugin: NxPlugin | RemotePlugin): plugin is NxPluginV1;
-export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
 export declare function getDefaultPlugins(root: string): Promise<string[]>;

package/src/project-graph/plugins/internal-api.js

@@ -2,10 +2,8 @@
 // This file contains the bits and bobs of the internal API for loading and interacting with Nx plugins.
 // For the public API, used by plugin authors, see `./public-api.ts`.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultPlugins = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = exports.loadNxPlugin = exports.loadNxPlugins = exports.nxPluginCache = void 0;
+exports.getDefaultPlugins = exports.loadNxPlugin = exports.loadNxPlugins = exports.nxPluginCache = void 0;
 const path_1 = require("path");
-const workspaces_1 = require("../../config/workspaces");
-const globs_1 = require("../../utils/globs");
 const workspace_root_1 = require("../../utils/workspace-root");
 const angular_json_1 = require("../../adapter/angular-json");
 const plugin_pool_1 = require("./plugin-pool");
@@ -36,40 +34,6 @@ async function loadNxPlugin(plugin, root = workspace_root_1.workspaceRoot) {
     return loadedPlugin;
 }
 exports.loadNxPlugin = loadNxPlugin;
-function isNxPluginV2(plugin) {
-    return 'createNodes' in plugin || 'createDependencies' in plugin;
-}
-exports.isNxPluginV2 = isNxPluginV2;
-function isNxPluginV1(plugin) {
-    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
-}
-exports.isNxPluginV1 = isNxPluginV1;
-function normalizeNxPlugin(plugin) {
-    if (isNxPluginV2(plugin)) {
-        return plugin;
-    }
-    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
-        return {
-            ...plugin,
-            createNodes: [
-                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
-                (configFilePath) => {
-                    const root = (0, path_1.dirname)(configFilePath);
-                    return {
-                        projects: {
-                            [root]: {
-                                name: (0, workspaces_1.toProjectName)(configFilePath),
-                                targets: plugin.registerProjectTargets?.(configFilePath),
-                            },
-                        },
-                    };
-                },
-            ],
-        };
-    }
-    return plugin;
-}
-exports.normalizeNxPlugin = normalizeNxPlugin;
 async function getDefaultPlugins(root) {
     return [
         (0, path_1.join)(__dirname, '../../plugins/js'),

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

@@ -22,15 +22,12 @@ export interface PluginWorkerLoadResult {
         error: string;
     };
 }
-export interface PluginWorkerShutdownMessage {
-    type: 'shutdown';
-    payload: undefined;
-}
 export interface PluginWorkerCreateNodesMessage {
     type: 'createNodes';
     payload: {
         configFiles: string[];
         context: CreateNodesContext;
+        tx: string;
     };
 }
 export interface PluginWorkerCreateNodesResult {
@@ -38,15 +35,18 @@ export interface PluginWorkerCreateNodesResult {
     payload: {
         success: true;
         result: Awaited<ReturnType<RemotePlugin['createNodes'][1]>>;
+        tx: string;
     } | {
         success: false;
         error: string;
+        tx: string;
     };
 }
 export interface PluginCreateDependenciesMessage {
     type: 'createDependencies';
     payload: {
         context: CreateDependenciesContext;
+        tx: string;
     };
 }
 export interface PluginCreateDependenciesResult {
@@ -54,9 +54,11 @@ export interface PluginCreateDependenciesResult {
     payload: {
         dependencies: ReturnType<RemotePlugin['createDependencies']>;
         success: true;
+        tx: string;
     } | {
         success: false;
         error: string;
+        tx: string;
     };
 }
 export interface PluginWorkerProcessProjectGraphMessage {
@@ -64,6 +66,7 @@ export interface PluginWorkerProcessProjectGraphMessage {
     payload: {
         graph: ProjectGraph;
         ctx: ProjectGraphProcessorContext;
+        tx: string;
     };
 }
 export interface PluginWorkerProcessProjectGraphResult {
@@ -71,12 +74,14 @@ export interface PluginWorkerProcessProjectGraphResult {
     payload: {
         graph: ProjectGraph;
         success: true;
+        tx: string;
     } | {
         success: false;
         error: string;
+        tx: string;
     };
 }
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerShutdownMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage;
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage;
 export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult;
 type MaybePromise<T> = T | Promise<T>;
 type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;

package/src/project-graph/plugins/plugin-pool.d.ts

@@ -1,4 +1,4 @@
 import { PluginConfiguration } from '../../config/nx-json';
 import { RemotePlugin } from './internal-api';
 export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): Promise<RemotePlugin>;
-export declare function shutdownPluginWorkers(): Promise<any[]>;
+export declare function shutdownPluginWorkers(): Promise<void>;

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

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.shutdownPluginWorkers = exports.loadRemoteNxPlugin = void 0;
 const child_process_1 = require("child_process");
 const path = require("path");
-const logger_1 = require("../../utils/logger");
+// TODO (@AgentEnder): After scoped verbose logging is implemented, re-add verbose logs here.
+// import { logger } from '../../utils/logger';
 const internal_api_1 = require("./internal-api");
 const messaging_1 = require("./messaging");
-const pool = [];
+const pool = new Set();
 const pidMap = new Map();
+// transaction id (tx) -> Promise, Resolver, Rejecter
+// Makes sure that we can resolve the correct promise when the worker sends back the result
+const promiseBank = new Map();
 function loadRemoteNxPlugin(plugin, root) {
     // this should only really be true when running unit tests within
     // the Nx repo. We still need to start the worker in this case,
@@ -32,11 +36,11 @@ function loadRemoteNxPlugin(plugin, root) {
         ],
     });
     worker.send((0, messaging_1.createMessage)({ type: 'load', payload: { plugin, root } }));
-    pool.push(worker);
-    logger_1.logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
+    pool.add(worker);
+    // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
     return new Promise((res, rej) => {
         worker.on('message', createWorkerHandler(worker, res, rej));
-        worker.on('exit', () => workerOnExitHandler(worker));
+        worker.on('exit', createWorkerExitHandler(worker));
     });
 }
 exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
@@ -46,22 +50,19 @@ async function shutdownPluginWorkers() {
     internal_api_1.nxPluginCache.clear();
     // Marks the workers as shutdown so that we don't report unexpected exits
     pluginWorkersShutdown = true;
-    const promises = [];
+    // logger.verbose(`[plugin-pool] starting worker shutdown`);
+    const pending = getPendingPromises(pool, pidMap);
+    if (pending.length > 0) {
+        // logger.verbose(
+        //   `[plugin-pool] waiting for ${pending.length} pending operations to complete`
+        // );
+        await Promise.all(pending);
+    }
+    // logger.verbose(`[plugin-pool] all pending operations completed`);
     for (const p of pool) {
-        p.send((0, messaging_1.createMessage)({ type: 'shutdown', payload: undefined }), (error) => {
-            if (error) {
-                // This occurs when the worker is already dead, and we can ignore it
-            }
-            else {
-                promises.push(
-                // Create a promise that resolves when the worker exits
-                new Promise((res, rej) => {
-                    p.once('exit', () => res());
-                }));
-            }
-        });
+        p.kill('SIGINT');
     }
-    return Promise.all(promises);
+    // logger.verbose(`[plugin-pool] all workers killed`);
 }
 exports.shutdownPluginWorkers = shutdownPluginWorkers;
 /**
@@ -72,67 +73,74 @@ exports.shutdownPluginWorkers = shutdownPluginWorkers;
  * @returns Function to handle messages from the worker
  */
 function createWorkerHandler(worker, onload, onloadError) {
-    // We store resolver and rejecter functions in the outer scope so that we can
-    // resolve/reject the promise from the message handler. The flow is something like:
-    // 1. plugin api called
-    // 2. remote plugin sends message to worker, creates promise and stores resolver/rejecter
-    // 3. worker performs API request
-    // 4. worker sends result back to main process
-    // 5. main process resolves/rejects promise based on result
-    let createNodesResolver;
-    let createNodesRejecter;
-    let createDependenciesResolver;
-    let createDependenciesRejecter;
-    let processProjectGraphResolver;
-    let processProjectGraphRejecter;
     let pluginName;
     return function (message) {
         const parsed = JSON.parse(message);
-        logger_1.logger.verbose(`[plugin-pool] received message: ${parsed.type} from ${pluginName ?? worker.pid}`);
+        // logger.verbose(
+        //   `[plugin-pool] received message: ${parsed.type} from ${
+        //     pluginName ?? worker.pid
+        //   }`
+        // );
         (0, messaging_1.consumeMessage)(parsed, {
             'load-result': (result) => {
                 if (result.success) {
                     const { name, createNodesPattern } = result;
                     pluginName = name;
-                    pidMap.set(worker.pid, name);
+                    const pending = new Set();
+                    pidMap.set(worker.pid, { name, pending });
                     onload({
                         name,
                         createNodes: createNodesPattern
                             ? [
                                 createNodesPattern,
                                 (configFiles, ctx) => {
-                                    return new Promise((res, rej) => {
+                                    return new Promise(function (res, rej) {
+                                        const tx = pluginName + ':createNodes:' + performance.now();
                                         worker.send((0, messaging_1.createMessage)({
                                             type: 'createNodes',
-                                            payload: { configFiles, context: ctx },
+                                            payload: { configFiles, context: ctx, tx },
                                         }));
-                                        createNodesResolver = res;
-                                        createNodesRejecter = rej;
+                                        pending.add(tx);
+                                        promiseBank.set(tx, {
+                                            promise: this,
+                                            resolver: res,
+                                            rejecter: rej,
+                                        });
                                     });
                                 },
                             ]
                             : undefined,
                         createDependencies: result.hasCreateDependencies
                             ? (opts, ctx) => {
-                                return new Promise((res, rej) => {
+                                return new Promise(function (res, rej) {
+                                    const tx = pluginName + ':createNodes:' + performance.now();
                                     worker.send((0, messaging_1.createMessage)({
                                         type: 'createDependencies',
-                                        payload: { context: ctx },
+                                        payload: { context: ctx, tx },
                                     }));
-                                    createDependenciesResolver = res;
-                                    createDependenciesRejecter = rej;
+                                    pending.add(tx);
+                                    promiseBank.set(tx, {
+                                        promise: this,
+                                        resolver: res,
+                                        rejecter: rej,
+                                    });
                                 });
                             }
                             : undefined,
                         processProjectGraph: result.hasProcessProjectGraph
                             ? (graph, ctx) => {
-                                return new Promise((res, rej) => {
+                                return new Promise(function (res, rej) {
+                                    const tx = pluginName + ':processProjectGraph:' + performance.now();
                                     worker.send((0, messaging_1.createMessage)({
                                         type: 'processProjectGraph',
-                                        payload: { graph, ctx },
+                                        payload: { graph, ctx, tx },
                                     }));
-                                    processProjectGraphResolver = res;
-                                    processProjectGraphRejecter = rej;
+                                    pending.add(tx);
+                                    promiseBank.set(tx, {
+                                        promise: this,
+                                        resolver: res,
+                                        rejecter: rej,
+                                    });
                                 });
                             }
                             : undefined,
@@ -142,47 +150,65 @@ function createWorkerHandler(worker, onload, onloadError) {
                     onloadError(result.error);
                 }
             },
-            createDependenciesResult: (result) => {
+            createDependenciesResult: ({ tx, ...result }) => {
+                const { resolver, rejecter } = promiseBank.get(tx);
                 if (result.success) {
-                    createDependenciesResolver(result.dependencies);
-                    createDependenciesResolver = undefined;
+                    resolver(result.dependencies);
                 }
                 else if (result.success === false) {
-                    createDependenciesRejecter(result.error);
-                    createDependenciesRejecter = undefined;
+                    rejecter(result.error);
                 }
+                pidMap.get(worker.pid)?.pending.delete(tx);
+                promiseBank.delete(tx);
             },
-            createNodesResult: (payload) => {
-                if (payload.success) {
-                    createNodesResolver(payload.result);
-                    createNodesResolver = undefined;
+            createNodesResult: ({ tx, ...result }) => {
+                const { resolver, rejecter } = promiseBank.get(tx);
+                if (result.success) {
+                    resolver(result.result);
                 }
-                else if (payload.success === false) {
-                    createNodesRejecter(payload.error);
-                    createNodesRejecter = undefined;
+                else if (result.success === false) {
+                    rejecter(result.error);
                 }
+                pidMap.get(worker.pid)?.pending.delete(tx);
+                promiseBank.delete(tx);
             },
-            processProjectGraphResult: (result) => {
+            processProjectGraphResult: ({ tx, ...result }) => {
+                const { resolver, rejecter } = promiseBank.get(tx);
                 if (result.success) {
-                    processProjectGraphResolver(result.graph);
-                    processProjectGraphResolver = undefined;
+                    resolver(result.graph);
                 }
                 else if (result.success === false) {
-                    processProjectGraphRejecter(result.error);
-                    processProjectGraphRejecter = undefined;
+                    rejecter(result.error);
                 }
+                pidMap.get(worker.pid)?.pending.delete(tx);
+                promiseBank.delete(tx);
             },
         });
     };
 }
-function workerOnExitHandler(worker) {
+function createWorkerExitHandler(worker) {
     return () => {
         if (!pluginWorkersShutdown) {
+            pidMap.get(worker.pid)?.pending.forEach((tx) => {
+                const { rejecter } = promiseBank.get(tx);
+                rejecter(new Error(`Plugin worker ${pidMap.get(worker.pid).name ?? worker.pid} exited unexpectedly with code ${worker.exitCode}`));
+            });
             shutdownPluginWorkers();
-            throw new Error(`[Nx] plugin worker ${pidMap.get(worker.pid) ?? worker.pid} exited unexpectedly`);
         }
     };
 }
 process.on('exit', () => {
-    shutdownPluginWorkers();
+    if (pool.size) {
+        shutdownPluginWorkers();
+    }
 });
+function getPendingPromises(pool, pidMap) {
+    const pendingTxs = [];
+    for (const p of pool) {
+        const { pending } = pidMap.get(p.pid) ?? { pending: new Set() };
+        for (const tx of pending) {
+            pendingTxs.push(promiseBank.get(tx)?.promise);
+        }
+    }
+    return pendingTxs;
+}

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

@@ -4,6 +4,7 @@ const installation_directory_1 = require("../../utils/installation-directory");
 const worker_api_1 = require("./worker-api");
 const messaging_1 = require("./messaging");
 const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+const utils_1 = require("./utils");
 global.NX_GRAPH_CREATION = true;
 let plugin;
 let pluginOptions;
@@ -34,51 +35,48 @@ process.on('message', async (message) => {
                 };
             }
         },
-        shutdown: async () => {
-            process.exit(0);
-        },
-        createNodes: async ({ configFiles, context }) => {
+        createNodes: async ({ configFiles, context, tx }) => {
             try {
                 const result = await runCreateNodesInParallel(configFiles, context);
                 return {
                     type: 'createNodesResult',
-                    payload: { result, success: true },
+                    payload: { result, success: true, tx },
                 };
             }
             catch (e) {
                 return {
                     type: 'createNodesResult',
-                    payload: { success: false, error: e.stack },
+                    payload: { success: false, error: e.stack, tx },
                 };
             }
         },
-        createDependencies: async (payload) => {
+        createDependencies: async ({ context, tx }) => {
             try {
-                const result = await plugin.createDependencies(pluginOptions, payload.context);
+                const result = await plugin.createDependencies(pluginOptions, context);
                 return {
                     type: 'createDependenciesResult',
-                    payload: { dependencies: result, success: true },
+                    payload: { dependencies: result, success: true, tx },
                 };
             }
             catch (e) {
                 return {
                     type: 'createDependenciesResult',
-                    payload: { success: false, error: e.stack },
+                    payload: { success: false, error: e.stack, tx },
                 };
             }
         },
-        processProjectGraph: async ({ graph, ctx }) => {
+        processProjectGraph: async ({ graph, ctx, tx }) => {
             try {
                 const result = await plugin.processProjectGraph(graph, ctx);
                 return {
                     type: 'processProjectGraphResult',
-                    payload: { graph: result, success: true },
+                    payload: { graph: result, success: true, tx },
                 };
             }
             catch (e) {
                 return {
                     type: 'processProjectGraphResult',
-                    payload: { success: false, error: e.stack },
+                    payload: { success: false, error: e.stack, tx },
                 };
             }
         },
@@ -99,24 +97,19 @@ async function loadPluginFromWorker(plugin, root) {
 function runCreateNodesInParallel(configFiles, context) {
     const promises = configFiles.map((file) => {
         performance.mark(`${plugin.name}:createNodes:${file} - start`);
-        const value = plugin.createNodes[1](file, pluginOptions, context);
-        if (value instanceof Promise) {
-            return value
-                .catch((e) => {
-                performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                throw new Error(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
-            })
-                .then((r) => {
-                performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-                return { ...r, pluginName: plugin.name, file };
-            });
-        }
-        else {
+        // Result is either static or a promise, using Promise.resolve lets us
+        // handle both cases with same logic
+        const value = Promise.resolve(plugin.createNodes[1](file, pluginOptions, context));
+        return value
+            .catch((e) => {
+            performance.mark(`${plugin.name}:createNodes:${file} - end`);
+            throw new utils_1.CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+        })
+            .then((r) => {
             performance.mark(`${plugin.name}:createNodes:${file} - end`);
             performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-            return { ...value, pluginName: plugin.name, file };
-        }
+            return { ...r, pluginName: plugin.name, file };
+        });
     });
     return Promise.all(promises);
 }

package/src/project-graph/plugins/utils.d.ts

@@ -0,0 +1,9 @@
+import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import type { NormalizedPlugin, RemotePlugin } from './internal-api';
+import type { NxPlugin, NxPluginV2 } from './public-api';
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin | RemotePlugin): plugin is NxPluginV1;
+export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
+export declare class CreateNodesError extends Error {
+    constructor(msg: any, cause: Error | unknown);
+}

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateNodesError = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
+const node_path_1 = require("node:path");
+const workspaces_1 = require("../../config/workspaces");
+const globs_1 = require("../../utils/globs");
+function isNxPluginV2(plugin) {
+    return 'createNodes' in plugin || 'createDependencies' in plugin;
+}
+exports.isNxPluginV2 = isNxPluginV2;
+function isNxPluginV1(plugin) {
+    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
+}
+exports.isNxPluginV1 = isNxPluginV1;
+function normalizeNxPlugin(plugin) {
+    if (isNxPluginV2(plugin)) {
+        return plugin;
+    }
+    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
+        return {
+            ...plugin,
+            createNodes: [
+                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
+                (configFilePath) => {
+                    const root = (0, node_path_1.dirname)(configFilePath);
+                    return {
+                        projects: {
+                            [root]: {
+                                name: (0, workspaces_1.toProjectName)(configFilePath),
+                                targets: plugin.registerProjectTargets?.(configFilePath),
+                            },
+                        },
+                    };
+                },
+            ],
+        };
+    }
+    return plugin;
+}
+exports.normalizeNxPlugin = normalizeNxPlugin;
+class CreateNodesError extends Error {
+    constructor(msg, cause) {
+        const message = `${msg} ${!cause
+            ? ''
+            : cause instanceof Error
+                ? `\n\n\t Inner Error: ${cause.stack}`
+                : cause}`;
+        // These errors are thrown during a JS callback which is invoked via rust.
+        // The errors messaging gets lost in the rust -> js -> rust transition, but
+        // logging the error here will ensure that it is visible in the console.
+        console.error(message);
+        super(message, { cause });
+    }
+}
+exports.CreateNodesError = CreateNodesError;

package/src/project-graph/plugins/worker-api.js

@@ -15,14 +15,14 @@ const find_project_for_path_1 = require("../utils/find-project-for-path");
 const path_1 = require("../../utils/path");
 const logger_1 = require("../../utils/logger");
 const node_path_1 = require("node:path");
-const internal_api_1 = require("./internal-api");
+const utils_1 = require("./utils");
 async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
     const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
         ? pluginConfiguration
         : { plugin: pluginConfiguration, options: undefined };
     performance.mark(`Load Nx Plugin: ${moduleName} - start`);
     let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
-    const plugin = (0, internal_api_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
+    const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
     plugin.name ??= name;
     performance.mark(`Load Nx Plugin: ${moduleName} - end`);
     performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);

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

@@ -7,6 +7,8 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const target_defaults_plugin_1 = require("../../plugins/target-defaults/target-defaults-plugin");
 const minimatch_1 = require("minimatch");
 const path_1 = require("path");
+const utils_1 = require("../plugins/utils");
+const plugin_pool_1 = require("../plugins/plugin-pool");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -146,16 +148,13 @@ plugins, root = workspace_root_1.workspaceRoot) {
                 matchedFiles.push(file);
             }
         }
-        try {
-            let r = createNodes(matchedFiles, {
-                nxJsonConfiguration: nxJson,
-                workspaceRoot: root,
-            });
-            results.push(r);
-        }
-        catch (e) {
-            throw new CreateNodesError(`Unable to create nodes using plugin ${plugin.name}.`, e);
-        }
+        let r = createNodes(matchedFiles, {
+            nxJsonConfiguration: nxJson,
+            workspaceRoot: root,
+        }).catch((e) => (0, plugin_pool_1.shutdownPluginWorkers)().then(() => {
+            throw e;
+        }));
+        results.push(r);
     }
     return Promise.all(results).then((results) => {
         performance.mark('createNodes:merge - start');
@@ -173,7 +172,7 @@ plugins, root = workspace_root_1.workspaceRoot) {
                     mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, [file, pluginName]);
                 }
                 catch (e) {
-                    throw new CreateNodesError(`Unable to merge project information for "${project.root}" from ${result.file} using plugin ${result.pluginName}.`, e);
+                    throw new utils_1.CreateNodesError(`Unable to merge project information for "${project.root}" from ${result.file} using plugin ${result.pluginName}.`, e);
                 }
             }
             Object.assign(externalNodes, pluginExternalNodes);
@@ -229,20 +228,6 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
-class CreateNodesError extends Error {
-    constructor(msg, cause) {
-        const message = `${msg} ${!cause
-            ? ''
-            : cause instanceof Error
-                ? `\n\n\t Inner Error: ${cause.stack}`
-                : cause}`;
-        // These errors are thrown during a JS callback which is invoked via rust.
-        // The errors messaging gets lost in the rust -> js -> rust transition, but
-        // logging the error here will ensure that it is visible in the console.
-        console.error(message);
-        super(message, { cause });
-    }
-}
 /**
  * Merges two targets.
  *