nx 18.1.0-canary.20240223-21e7648 → 18.1.0-canary.20240224-26b266f

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

@@ -8,14 +8,14 @@ const assert_workspace_validity_1 = require("../utils/assert-workspace-validity"
 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 nx_plugin_1 = require("../utils/nx-plugin");
+const internal_api_1 = require("./plugins/internal-api");
 const typescript_1 = require("../plugins/js/utils/typescript");
 const fileutils_1 = require("../utils/fileutils");
 const project_graph_builder_1 = require("./project-graph-builder");
 const configuration_1 = require("../config/configuration");
 const fs_1 = require("fs");
-const installation_directory_1 = require("../utils/installation-directory");
 const output_1 = require("../utils/output");
+const plugin_pool_1 = require("./plugins/plugin-pool");
 let storedFileMap = null;
 let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
@@ -70,6 +70,7 @@ async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fil
     if (shouldWriteCache) {
         (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
     }
+    await (0, plugin_pool_1.shutdownPluginWorkers)();
     return {
         projectGraph,
         projectFileMapCache,
@@ -140,11 +141,11 @@ function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess)
     };
 }
 async function updateProjectGraphWithPlugins(context, initProjectGraph) {
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(context.nxJsonConfiguration?.plugins, (0, installation_directory_1.getNxRequirePaths)(), context.workspaceRoot, context.projects);
+    const plugins = await (0, internal_api_1.loadNxPlugins)(context.nxJsonConfiguration?.plugins, context.workspaceRoot);
     let graph = initProjectGraph;
-    for (const { plugin } of plugins) {
+    for (const plugin of plugins) {
         try {
-            if ((0, nx_plugin_1.isNxPluginV1)(plugin) &&
+            if ((0, internal_api_1.isNxPluginV1)(plugin) &&
                 plugin.processProjectGraph &&
                 !plugin.createDependencies) {
                 output_1.output.warn({
@@ -182,13 +183,14 @@ 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, nx_plugin_1.isNxPluginV2)(plugin) && plugin.createDependencies);
-    await Promise.all(createDependencyPlugins.map(async ({ plugin, options }) => {
+    const createDependencyPlugins = plugins.filter((plugin) => (0, internal_api_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
         global.NX_GRAPH_CREATION = true;
         try {
-            const dependencies = await plugin.createDependencies(options, {
+            // TODO: we shouldn't have to pass null here
+            const dependencies = await plugin.createDependencies(null, {
                 ...context,
             });
             for (const dep of dependencies) {

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

@@ -147,21 +147,21 @@ Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: funct
  * TODO(v19): Remove this function.
  */
 function getProjectsSyncNoInference(root, nxJson) {
-    const projectFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
+    const projectFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root).map((p) => p.plugin));
     const plugins = [
         { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
         ...(0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root),
     ];
     const projectRootMap = new Map();
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const { plugin, options } of plugins) {
+    for (const { plugin } of plugins) {
         const [pattern, createNodes] = plugin.createNodes ?? [];
         if (!pattern) {
             continue;
         }
         for (const file of projectFiles) {
             if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                let r = createNodes(file, options, {
+                let r = createNodes(file, {}, {
                     nxJsonConfiguration: nxJson,
                     workspaceRoot: root,
                 });

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

@@ -0,0 +1,2 @@
+export * from './public-api';
+export { readPluginPackageJson, registerPluginTSTranspiler, } from './worker-api';

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./public-api"), exports);
+var worker_api_1 = require("./worker-api");
+Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return worker_api_1.readPluginPackageJson; } });
+Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return worker_api_1.registerPluginTSTranspiler; } });

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

@@ -0,0 +1,21 @@
+import { PluginConfiguration } from '../../config/nx-json';
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { CreateNodesContext, CreateNodesResult, NxPlugin, NxPluginV2 } from './public-api';
+export type CreateNodesResultWithContext = CreateNodesResult & {
+    file: string;
+    pluginName: string;
+};
+export type NormalizedPlugin = NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
+export type RemotePlugin = Omit<NormalizedPlugin, 'createNodes'> & {
+    createNodes: [
+        filePattern: string,
+        fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<CreateNodesResultWithContext[]>
+    ];
+};
+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

@@ -0,0 +1,84 @@
+"use strict";
+// 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;
+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");
+// Short lived cache (cleared between cmd runs)
+// holding resolved nx plugin objects.
+// Allows loaded plugins to not be reloaded when
+// referenced multiple times.
+exports.nxPluginCache = new Map();
+async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
+    const result = [];
+    plugins ??= [];
+    plugins.unshift((0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/package-json-next-to-project-json'));
+    // We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
+    plugins.push(...(await getDefaultPlugins(root)));
+    for (const plugin of plugins) {
+        result.push(loadNxPlugin(plugin, root));
+    }
+    return Promise.all(result);
+}
+exports.loadNxPlugins = loadNxPlugins;
+async function loadNxPlugin(plugin, root = workspace_root_1.workspaceRoot) {
+    const cacheKey = JSON.stringify(plugin);
+    if (exports.nxPluginCache.has(cacheKey)) {
+        return exports.nxPluginCache.get(cacheKey);
+    }
+    const loadedPlugin = await (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
+    exports.nxPluginCache.set(cacheKey, loadedPlugin);
+    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'),
+        (0, path_1.join)(__dirname, '../../plugins/target-defaults/target-defaults-plugin'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [(0, path_1.join)(__dirname, '../../adapter/angular-json')]
+            : []),
+        (0, path_1.join)(__dirname, '../../plugins/package-json-workspaces'),
+        (0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
+    ];
+}
+exports.getDefaultPlugins = getDefaultPlugins;

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

@@ -0,0 +1,89 @@
+import { ProjectGraph, ProjectGraphProcessorContext } from '../../config/project-graph';
+import { PluginConfiguration } from '../../config/nx-json';
+import { CreateDependenciesContext, CreateNodesContext } from './public-api';
+import { RemotePlugin } from './internal-api';
+export interface PluginWorkerLoadMessage {
+    type: 'load';
+    payload: {
+        plugin: PluginConfiguration;
+        root: string;
+    };
+}
+export interface PluginWorkerLoadResult {
+    type: 'load-result';
+    payload: {
+        name: string;
+        createNodesPattern: string;
+        hasCreateDependencies: boolean;
+        hasProcessProjectGraph: boolean;
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    };
+}
+export interface PluginWorkerShutdownMessage {
+    type: 'shutdown';
+    payload: undefined;
+}
+export interface PluginWorkerCreateNodesMessage {
+    type: 'createNodes';
+    payload: {
+        configFiles: string[];
+        context: CreateNodesContext;
+    };
+}
+export interface PluginWorkerCreateNodesResult {
+    type: 'createNodesResult';
+    payload: {
+        success: true;
+        result: Awaited<ReturnType<RemotePlugin['createNodes'][1]>>;
+    } | {
+        success: false;
+        error: string;
+    };
+}
+export interface PluginCreateDependenciesMessage {
+    type: 'createDependencies';
+    payload: {
+        context: CreateDependenciesContext;
+    };
+}
+export interface PluginCreateDependenciesResult {
+    type: 'createDependenciesResult';
+    payload: {
+        dependencies: ReturnType<RemotePlugin['createDependencies']>;
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    };
+}
+export interface PluginWorkerProcessProjectGraphMessage {
+    type: 'processProjectGraph';
+    payload: {
+        graph: ProjectGraph;
+        ctx: ProjectGraphProcessorContext;
+    };
+}
+export interface PluginWorkerProcessProjectGraphResult {
+    type: 'processProjectGraphResult';
+    payload: {
+        graph: ProjectGraph;
+        success: true;
+    } | {
+        success: false;
+        error: string;
+    };
+}
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerShutdownMessage | 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>;
+export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: string | T, handlers: {
+    [K in T['type']]: (payload: Extract<T, {
+        type: K;
+    }>['payload']) => MessageHandlerReturn<T>;
+}): Promise<void>;
+export declare function createMessage(message: PluginWorkerMessage | PluginWorkerResult): string;
+export {};

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessage = exports.consumeMessage = void 0;
+// Takes a message and a map of handlers and calls the appropriate handler
+// type safe and requires all handlers to be handled
+async function consumeMessage(raw, handlers) {
+    const message = typeof raw === 'string' ? JSON.parse(raw) : raw;
+    const handler = handlers[message.type];
+    if (handler) {
+        const response = await handler(message.payload);
+        if (response) {
+            process.send(createMessage(response));
+        }
+    }
+    else {
+        throw new Error(`Unhandled message type: ${message.type}`);
+    }
+}
+exports.consumeMessage = consumeMessage;
+function createMessage(message) {
+    return JSON.stringify(message);
+}
+exports.createMessage = createMessage;

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

@@ -0,0 +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[]>;

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

@@ -0,0 +1,188 @@
+"use strict";
+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");
+const internal_api_1 = require("./internal-api");
+const messaging_1 = require("./messaging");
+const pool = [];
+const pidMap = 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,
+    // but its typescript.
+    const isWorkerTypescript = path.extname(__filename) === '.ts';
+    const workerPath = path.join(__dirname, 'plugin-worker');
+    const worker = (0, child_process_1.fork)(workerPath, [], {
+        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+        env: {
+            ...process.env,
+            ...(isWorkerTypescript
+                ? {
+                    // Ensures that the worker uses the same tsconfig as the main process
+                    TS_NODE_PROJECT: path.join(__dirname, '../../../tsconfig.lib.json'),
+                }
+                : {}),
+        },
+        execArgv: [
+            ...process.execArgv,
+            // If the worker is typescript, we need to register ts-node
+            ...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
+        ],
+    });
+    worker.send((0, messaging_1.createMessage)({ type: 'load', payload: { plugin, root } }));
+    pool.push(worker);
+    logger_1.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));
+    });
+}
+exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
+let pluginWorkersShutdown = false;
+async function shutdownPluginWorkers() {
+    // Clears the plugin cache so no refs to the workers are held
+    internal_api_1.nxPluginCache.clear();
+    // Marks the workers as shutdown so that we don't report unexpected exits
+    pluginWorkersShutdown = true;
+    const promises = [];
+    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());
+                }));
+            }
+        });
+    }
+    return Promise.all(promises);
+}
+exports.shutdownPluginWorkers = shutdownPluginWorkers;
+/**
+ * Creates a message handler for the given worker.
+ * @param worker Instance of plugin-worker
+ * @param onload Resolver for RemotePlugin promise
+ * @param onloadError Rejecter for RemotePlugin promise
+ * @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}`);
+        (0, messaging_1.consumeMessage)(parsed, {
+            'load-result': (result) => {
+                if (result.success) {
+                    const { name, createNodesPattern } = result;
+                    pluginName = name;
+                    pidMap.set(worker.pid, name);
+                    onload({
+                        name,
+                        createNodes: createNodesPattern
+                            ? [
+                                createNodesPattern,
+                                (configFiles, ctx) => {
+                                    return new Promise((res, rej) => {
+                                        worker.send((0, messaging_1.createMessage)({
+                                            type: 'createNodes',
+                                            payload: { configFiles, context: ctx },
+                                        }));
+                                        createNodesResolver = res;
+                                        createNodesRejecter = rej;
+                                    });
+                                },
+                            ]
+                            : undefined,
+                        createDependencies: result.hasCreateDependencies
+                            ? (opts, ctx) => {
+                                return new Promise((res, rej) => {
+                                    worker.send((0, messaging_1.createMessage)({
+                                        type: 'createDependencies',
+                                        payload: { context: ctx },
+                                    }));
+                                    createDependenciesResolver = res;
+                                    createDependenciesRejecter = rej;
+                                });
+                            }
+                            : undefined,
+                        processProjectGraph: result.hasProcessProjectGraph
+                            ? (graph, ctx) => {
+                                return new Promise((res, rej) => {
+                                    worker.send((0, messaging_1.createMessage)({
+                                        type: 'processProjectGraph',
+                                        payload: { graph, ctx },
+                                    }));
+                                    processProjectGraphResolver = res;
+                                    processProjectGraphRejecter = rej;
+                                });
+                            }
+                            : undefined,
+                    });
+                }
+                else if (result.success === false) {
+                    onloadError(result.error);
+                }
+            },
+            createDependenciesResult: (result) => {
+                if (result.success) {
+                    createDependenciesResolver(result.dependencies);
+                    createDependenciesResolver = undefined;
+                }
+                else if (result.success === false) {
+                    createDependenciesRejecter(result.error);
+                    createDependenciesRejecter = undefined;
+                }
+            },
+            createNodesResult: (payload) => {
+                if (payload.success) {
+                    createNodesResolver(payload.result);
+                    createNodesResolver = undefined;
+                }
+                else if (payload.success === false) {
+                    createNodesRejecter(payload.error);
+                    createNodesRejecter = undefined;
+                }
+            },
+            processProjectGraphResult: (result) => {
+                if (result.success) {
+                    processProjectGraphResolver(result.graph);
+                    processProjectGraphResolver = undefined;
+                }
+                else if (result.success === false) {
+                    processProjectGraphRejecter(result.error);
+                    processProjectGraphRejecter = undefined;
+                }
+            },
+        });
+    };
+}
+function workerOnExitHandler(worker) {
+    return () => {
+        if (!pluginWorkersShutdown) {
+            shutdownPluginWorkers();
+            throw new Error(`[Nx] plugin worker ${pidMap.get(worker.pid) ?? worker.pid} exited unexpectedly`);
+        }
+    };
+}
+process.on('exit', () => {
+    shutdownPluginWorkers();
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+global.NX_GRAPH_CREATION = true;
+let plugin;
+let pluginOptions;
+process.on('message', async (message) => {
+    (0, messaging_1.consumeMessage)(message, {
+        load: async ({ plugin: pluginConfiguration, root }) => {
+            process.chdir(root);
+            try {
+                ({ plugin, options: pluginOptions } = await loadPluginFromWorker(pluginConfiguration, root));
+                return {
+                    type: 'load-result',
+                    payload: {
+                        name: plugin.name,
+                        createNodesPattern: plugin.createNodes?.[0],
+                        hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
+                        hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
+                        success: true,
+                    },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'load-result',
+                    payload: {
+                        success: false,
+                        error: `Could not load plugin ${plugin} \n ${e instanceof Error ? e.stack : ''}`,
+                    },
+                };
+            }
+        },
+        shutdown: async () => {
+            process.exit(0);
+        },
+        createNodes: async ({ configFiles, context }) => {
+            try {
+                const result = await runCreateNodesInParallel(configFiles, context);
+                return {
+                    type: 'createNodesResult',
+                    payload: { result, success: true },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'createNodesResult',
+                    payload: { success: false, error: e.stack },
+                };
+            }
+        },
+        createDependencies: async (payload) => {
+            try {
+                const result = await plugin.createDependencies(pluginOptions, payload.context);
+                return {
+                    type: 'createDependenciesResult',
+                    payload: { dependencies: result, success: true },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'createDependenciesResult',
+                    payload: { success: false, error: e.stack },
+                };
+            }
+        },
+        processProjectGraph: async ({ graph, ctx }) => {
+            try {
+                const result = await plugin.processProjectGraph(graph, ctx);
+                return {
+                    type: 'processProjectGraphResult',
+                    payload: { graph: result, success: true },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'processProjectGraphResult',
+                    payload: { success: false, error: e.stack },
+                };
+            }
+        },
+    });
+});
+let projectsWithoutInference;
+async function loadPluginFromWorker(plugin, root) {
+    try {
+        require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
+    }
+    catch {
+        // If a plugin cannot be resolved, we will need projects to resolve it
+        projectsWithoutInference ??=
+            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+    }
+    return await (0, worker_api_1.loadNxPluginAsync)(plugin, (0, installation_directory_1.getNxRequirePaths)(root), projectsWithoutInference, 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 {
+            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 Promise.all(promises);
+}