nx 18.3.0-canary.20240409-32144bb → 18.3.0-canary.20240410-7a7cbec

package/src/plugins/target-defaults/symbols.d.ts

@@ -0,0 +1,17 @@
+/**
+ * This marks that a target provides information which should modify a target already registered
+ * on the project via other plugins. If the target has not already been registered, and this symbol is true,
+ * the information provided by it will be discarded.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+export declare const ONLY_MODIFIES_EXISTING_TARGET = "NX_ONLY_MODIFIES_EXISTING_TARGET";
+/**
+ * This is used to override the source file for the target defaults plugin.
+ * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+export declare const OVERRIDE_SOURCE_FILE = "NX_OVERRIDE_SOURCE_FILE";

package/src/plugins/target-defaults/symbols.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OVERRIDE_SOURCE_FILE = exports.ONLY_MODIFIES_EXISTING_TARGET = void 0;
+/**
+ * This marks that a target provides information which should modify a target already registered
+ * on the project via other plugins. If the target has not already been registered, and this symbol is true,
+ * the information provided by it will be discarded.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+exports.ONLY_MODIFIES_EXISTING_TARGET = 'NX_ONLY_MODIFIES_EXISTING_TARGET';
+/**
+ * This is used to override the source file for the target defaults plugin.
+ * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
+ *
+ * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
+ * between the plugin-worker and the main process.
+ */
+exports.OVERRIDE_SOURCE_FILE = 'NX_OVERRIDE_SOURCE_FILE';

package/src/plugins/target-defaults/target-defaults-plugin.d.ts

@@ -1,23 +1,7 @@
 import { TargetConfiguration } from '../../config/workspace-json-project-json';
-import { NxPluginV2 } from '../../utils/nx-plugin';
-/**
- * This marks that a target provides information which should modify a target already registered
- * on the project via other plugins. If the target has not already been registered, and this symbol is true,
- * the information provided by it will be discarded.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-export declare const ONLY_MODIFIES_EXISTING_TARGET = "NX_ONLY_MODIFIES_EXISTING_TARGET";
-/**
- * This is used to override the source file for the target defaults plugin.
- * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-export declare const OVERRIDE_SOURCE_FILE = "NX_OVERRIDE_SOURCE_FILE";
+import { NxPluginV2 } from '../../project-graph/plugins';
 export declare const TargetDefaultsPlugin: NxPluginV2;
+export default TargetDefaultsPlugin;
 /**
  * This fn gets target info that would make a target uniquely compatible
  * with what is described by project.json or package.json. As the merge process

package/src/plugins/target-defaults/target-defaults-plugin.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTargetInfo = exports.TargetDefaultsPlugin = exports.OVERRIDE_SOURCE_FILE = exports.ONLY_MODIFIES_EXISTING_TARGET = void 0;
+exports.getTargetInfo = exports.TargetDefaultsPlugin = void 0;
 const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -8,23 +8,7 @@ const fileutils_1 = require("../../utils/fileutils");
 const globs_1 = require("../../utils/globs");
 const package_json_1 = require("../../utils/package-json");
 const package_json_workspaces_1 = require("../package-json-workspaces");
-/**
- * This marks that a target provides information which should modify a target already registered
- * on the project via other plugins. If the target has not already been registered, and this symbol is true,
- * the information provided by it will be discarded.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-exports.ONLY_MODIFIES_EXISTING_TARGET = 'NX_ONLY_MODIFIES_EXISTING_TARGET';
-/**
- * This is used to override the source file for the target defaults plugin.
- * This allows the plugin to use the project files as the context, but point to nx.json as the source file.
- *
- * NOTE: This cannot be a symbol, as they are not serialized in JSON the communication
- * between the plugin-worker and the main process.
- */
-exports.OVERRIDE_SOURCE_FILE = 'NX_OVERRIDE_SOURCE_FILE';
+const symbols_1 = require("./symbols");
 exports.TargetDefaultsPlugin = {
     name: 'nx/core/target-defaults',
     createNodes: [
@@ -72,7 +56,7 @@ exports.TargetDefaultsPlugin = {
                     // TODO: Remove this after we figure out a way to define new targets
                     // in target defaults
                     if (!projectDefinedTargets.has(targetName)) {
-                        modifiedTargets[targetName][exports.ONLY_MODIFIES_EXISTING_TARGET] = true;
+                        modifiedTargets[targetName][symbols_1.ONLY_MODIFIES_EXISTING_TARGET] = true;
                     }
                 }
             }
@@ -82,11 +66,12 @@ exports.TargetDefaultsPlugin = {
                         targets: modifiedTargets,
                     },
                 },
-                [exports.OVERRIDE_SOURCE_FILE]: 'nx.json',
+                [symbols_1.OVERRIDE_SOURCE_FILE]: 'nx.json',
             };
         },
     ],
 };
+exports.default = exports.TargetDefaultsPlugin;
 function getExecutorToTargetMap(packageJsonTargets, projectJsonTargets) {
     const executorToTargetMap = new Map();
     const targets = Object.keys({

package/src/project-graph/affected/locators/project-glob-changes.js

@@ -3,14 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedProjectsFromProjectGlobChanges = void 0;
 const minimatch_1 = require("minimatch");
 const workspace_root_1 = require("../../../utils/workspace-root");
-const installation_directory_1 = require("../../../utils/installation-directory");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const retrieve_workspace_files_1 = require("../../utils/retrieve-workspace-files");
-const nx_plugin_1 = require("../../../utils/nx-plugin");
+const internal_api_1 = require("../../plugins/internal-api");
 const globs_1 = require("../../../utils/globs");
 const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes, nxJson) => {
-    const globPattern = (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.configurationGlobs)(await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins, (0, installation_directory_1.getNxRequirePaths)(workspace_root_1.workspaceRoot), workspace_root_1.workspaceRoot)));
+    const [plugins] = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspace_root_1.workspaceRoot);
+    const globPattern = (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.configurationGlobs)(plugins));
     const touchedProjects = new Set();
     for (const touchedFile of touchedFiles) {
         const isProjectFile = (0, minimatch_1.minimatch)(touchedFile.file, globPattern, {

package/src/project-graph/build-project-graph.d.ts

@@ -1,5 +1,6 @@
 import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
+import { LoadedNxPlugin } from './plugins/internal-api';
 import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { NxWorkspaceFilesExternals } from '../native';
@@ -8,7 +9,7 @@ export declare function getFileMap(): {
     allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null): Promise<{
+export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[]): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;

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

@@ -8,13 +8,12 @@ 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 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");
 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");
 let storedFileMap = null;
 let storedAllWorkspaceFiles = null;
@@ -39,7 +38,7 @@ function getFileMap() {
     }
 }
 exports.getFileMap = getFileMap;
-async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache) {
+async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins) {
     storedFileMap = fileMap;
     storedAllWorkspaceFiles = allWorkspaceFiles;
     storedRustReferences = rustReferences;
@@ -65,7 +64,7 @@ async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fil
         };
     }
     const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
-    let projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion);
+    let projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion, plugins);
     const projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig);
     return {
         projectGraph,
@@ -89,7 +88,7 @@ function readCombinedDeps() {
         ...installationPackageJson.devDependencies,
     };
 }
-async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion) {
+async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion, plugins) {
     perf_hooks_1.performance.mark('build project graph:start');
     const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
     builder.setVersion(projectGraphVersion);
@@ -101,7 +100,7 @@ async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFile
     let updatedGraph;
     let error;
     try {
-        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
+        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph, plugins);
     }
     catch (e) {
         if (e instanceof CreateDependenciesError) {
@@ -154,13 +153,12 @@ function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess)
         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);
+async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins) {
     let graph = initProjectGraph;
     const errors = [];
-    for (const { plugin } of plugins) {
+    for (const plugin of plugins) {
         try {
-            if ((0, nx_plugin_1.isNxPluginV1)(plugin) &&
+            if ((0, utils_1.isNxPluginV1)(plugin) &&
                 plugin.processProjectGraph &&
                 !plugin.createDependencies) {
                 output_1.output.warn({
@@ -195,11 +193,11 @@ 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, utils_1.isNxPluginV2)(plugin) && plugin.createDependencies);
+    await Promise.all(createDependencyPlugins.map(async (plugin) => {
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
         try {
-            const dependencies = await plugin.createDependencies(options, {
+            const dependencies = await plugin.createDependencies({
                 ...context,
             });
             for (const dep of dependencies) {

package/src/project-graph/error-types.d.ts

@@ -0,0 +1,34 @@
+import { CreateNodesResultWithContext } from './plugins/internal-api';
+import { ConfigurationResult } from './utils/project-configuration-utils';
+export declare class ProjectConfigurationsError extends Error {
+    readonly errors: Array<MergeNodesError | CreateNodesError>;
+    readonly partialProjectConfigurationsResult: ConfigurationResult;
+    constructor(errors: Array<MergeNodesError | CreateNodesError>, partialProjectConfigurationsResult: ConfigurationResult);
+}
+export declare class CreateNodesError extends Error {
+    file: string;
+    pluginName: string;
+    constructor({ file, pluginName, error, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+    });
+}
+export declare class AggregateCreateNodesError extends Error {
+    readonly pluginName: string;
+    readonly errors: Array<CreateNodesError>;
+    readonly partialResults: Array<CreateNodesResultWithContext>;
+    constructor(pluginName: string, errors: Array<CreateNodesError>, partialResults: Array<CreateNodesResultWithContext>);
+}
+export declare class MergeNodesError extends Error {
+    file: string;
+    pluginName: string;
+    constructor({ file, pluginName, error, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+    });
+}
+export declare function isCreateNodesError(e: unknown): e is CreateNodesError;
+export declare function isAggregateCreateNodesError(e: unknown): e is AggregateCreateNodesError;
+export declare function isMergeNodesError(e: unknown): e is MergeNodesError;

package/src/project-graph/error-types.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = void 0;
+class ProjectConfigurationsError extends Error {
+    constructor(errors, partialProjectConfigurationsResult) {
+        super('Failed to create project configurations');
+        this.errors = errors;
+        this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectConfigurationsError = ProjectConfigurationsError;
+class CreateNodesError extends Error {
+    constructor({ file, pluginName, error, }) {
+        const msg = `The "${pluginName}" plugin threw an error while creating nodes from ${file}:`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.CreateNodesError = CreateNodesError;
+class AggregateCreateNodesError extends Error {
+    constructor(pluginName, errors, partialResults) {
+        super('Failed to create nodes');
+        this.pluginName = pluginName;
+        this.errors = errors;
+        this.partialResults = partialResults;
+        this.name = this.constructor.name;
+    }
+}
+exports.AggregateCreateNodesError = AggregateCreateNodesError;
+class MergeNodesError extends Error {
+    constructor({ file, pluginName, error, }) {
+        const msg = `The nodes created from ${file} by the "${pluginName}" could not be merged into the project graph:`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.MergeNodesError = MergeNodesError;
+function isCreateNodesError(e) {
+    return (e instanceof CreateNodesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === CreateNodesError.prototype.name));
+}
+exports.isCreateNodesError = isCreateNodesError;
+function isAggregateCreateNodesError(e) {
+    return (e instanceof AggregateCreateNodesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === AggregateCreateNodesError.prototype.name));
+}
+exports.isAggregateCreateNodesError = isAggregateCreateNodesError;
+function isMergeNodesError(e) {
+    return (e instanceof MergeNodesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === MergeNodesError.prototype.name));
+}
+exports.isMergeNodesError = isMergeNodesError;

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

@@ -149,12 +149,12 @@ Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: funct
 function getProjectsSyncNoInference(root, nxJson) {
     const allConfigFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
     const plugins = [
-        { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
+        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;
@@ -162,7 +162,7 @@ function getProjectsSyncNoInference(root, nxJson) {
         const matchingConfigFiles = allConfigFiles.filter((file) => (0, minimatch_1.minimatch)(file, pattern, { dot: true }));
         for (const file of matchingConfigFiles) {
             if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                let r = createNodes(file, options, {
+                let r = createNodes(file, {}, {
                     nxJsonConfiguration: nxJson,
                     workspaceRoot: root,
                     configFiles: matchingConfigFiles,

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

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

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 loader_1 = require("./loader");
+Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return loader_1.readPluginPackageJson; } });
+Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return loader_1.registerPluginTSTranspiler; } });

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

@@ -0,0 +1,28 @@
+import { PluginConfiguration } from '../../config/nx-json';
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { CreateDependencies, CreateDependenciesContext, CreateNodesContext, CreateNodesResult, NxPluginV2 } from './public-api';
+import { ProjectGraphProcessor } from '../../config/project-graph';
+export declare class LoadedNxPlugin {
+    readonly name: string;
+    readonly createNodes?: [
+        filePattern: string,
+        fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<CreateNodesResultWithContext[]>
+    ];
+    readonly createDependencies?: (context: CreateDependenciesContext) => ReturnType<CreateDependencies>;
+    readonly processProjectGraph?: ProjectGraphProcessor;
+    readonly options?: unknown;
+    readonly include?: string[];
+    readonly exclude?: string[];
+    constructor(plugin: NormalizedPlugin, pluginDefinition: PluginConfiguration);
+}
+export type CreateNodesResultWithContext = CreateNodesResult & {
+    file: string;
+    pluginName: string;
+};
+export type NormalizedPlugin = NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
+export declare const nxPluginCache: Map<unknown, [
+    Promise<LoadedNxPlugin>,
+    () => void
+]>;
+export declare function loadNxPlugins(plugins: PluginConfiguration[], root?: string): Promise<[LoadedNxPlugin[], () => void]>;
+export declare function getDefaultPlugins(root: string): Promise<string[]>;

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

@@ -0,0 +1,85 @@
+"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.loadNxPlugins = exports.nxPluginCache = exports.LoadedNxPlugin = void 0;
+const path_1 = require("path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const angular_json_1 = require("../../adapter/angular-json");
+const utils_1 = require("./utils");
+const isolation_1 = require("./isolation");
+const loader_1 = require("./loader");
+class LoadedNxPlugin {
+    constructor(plugin, pluginDefinition) {
+        this.name = plugin.name;
+        if (typeof pluginDefinition !== 'string') {
+            this.options = pluginDefinition.options;
+            this.include = pluginDefinition.include;
+            this.exclude = pluginDefinition.exclude;
+        }
+        if (plugin.createNodes) {
+            this.createNodes = [
+                plugin.createNodes[0],
+                (files, context) => (0, utils_1.runCreateNodesInParallel)(files, plugin, this.options, context),
+            ];
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = (context) => plugin.createDependencies(this.options, context);
+        }
+        this.processProjectGraph = plugin.processProjectGraph;
+    }
+}
+exports.LoadedNxPlugin = LoadedNxPlugin;
+// 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 = [];
+    const loadingMethod = process.env.NX_ISOLATE_PLUGINS === 'true'
+        ? isolation_1.loadNxPluginInIsolation
+        : loader_1.loadNxPlugin;
+    plugins = await normalizePlugins(plugins, root);
+    const cleanupFunctions = [];
+    for (const plugin of plugins) {
+        const [loadedPluginPromise, cleanup] = loadingMethod(plugin, root);
+        result.push(loadedPluginPromise);
+        cleanupFunctions.push(cleanup);
+    }
+    return [
+        await Promise.all(result),
+        () => {
+            for (const fn of cleanupFunctions) {
+                fn();
+            }
+            if (loader_1.unregisterPluginTSTranspiler) {
+                (0, loader_1.unregisterPluginTSTranspiler)();
+            }
+        },
+    ];
+}
+exports.loadNxPlugins = loadNxPlugins;
+async function normalizePlugins(plugins, root) {
+    plugins ??= [];
+    return [
+        // This plugin adds targets that we want to be able to overwrite
+        // in any user-land plugin, so it has to be first :).
+        (0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/package-json-next-to-project-json'),
+        ...plugins,
+        // Most of the nx core node plugins go on the end, s.t. it overwrites any other plugins
+        ...(await getDefaultPlugins(root)),
+    ];
+}
+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/isolation/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginConfiguration } from '../../../config/nx-json';
+import { LoadedNxPlugin } from '../internal-api';
+export declare function loadNxPluginInIsolation(plugin: PluginConfiguration, root?: string): [Promise<LoadedNxPlugin>, () => void];

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNxPluginInIsolation = void 0;
+const workspace_root_1 = require("../../../utils/workspace-root");
+const plugin_pool_1 = require("./plugin-pool");
+const remotePluginCache = new Map();
+function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
+    const cacheKey = JSON.stringify(plugin);
+    if (remotePluginCache.has(cacheKey)) {
+        return remotePluginCache.get(cacheKey);
+    }
+    const [loadingPlugin, cleanup] = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
+    remotePluginCache.set(cacheKey, [loadingPlugin, cleanup]);
+    return [loadingPlugin, cleanup];
+}
+exports.loadNxPluginInIsolation = loadNxPluginInIsolation;

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

@@ -0,0 +1,94 @@
+import { ProjectGraph, ProjectGraphProcessorContext } from '../../../config/project-graph';
+import { PluginConfiguration } from '../../../config/nx-json';
+import { CreateDependenciesContext, CreateNodesContext } from '../public-api';
+import { LoadedNxPlugin } 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 PluginWorkerCreateNodesMessage {
+    type: 'createNodes';
+    payload: {
+        configFiles: string[];
+        context: CreateNodesContext;
+        tx: string;
+    };
+}
+export interface PluginWorkerCreateNodesResult {
+    type: 'createNodesResult';
+    payload: {
+        success: true;
+        result: Awaited<ReturnType<LoadedNxPlugin['createNodes'][1]>>;
+        tx: string;
+    } | {
+        success: false;
+        error: string;
+        tx: string;
+    };
+}
+export interface PluginCreateDependenciesMessage {
+    type: 'createDependencies';
+    payload: {
+        context: CreateDependenciesContext;
+        tx: string;
+    };
+}
+export interface PluginCreateDependenciesResult {
+    type: 'createDependenciesResult';
+    payload: {
+        dependencies: ReturnType<LoadedNxPlugin['createDependencies']>;
+        success: true;
+        tx: string;
+    } | {
+        success: false;
+        error: string;
+        tx: string;
+    };
+}
+export interface PluginWorkerProcessProjectGraphMessage {
+    type: 'processProjectGraph';
+    payload: {
+        graph: ProjectGraph;
+        ctx: ProjectGraphProcessorContext;
+        tx: string;
+    };
+}
+export interface PluginWorkerProcessProjectGraphResult {
+    type: 'processProjectGraphResult';
+    payload: {
+        graph: ProjectGraph;
+        success: true;
+        tx: string;
+    } | {
+        success: false;
+        error: string;
+        tx: string;
+    };
+}
+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>;
+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/isolation/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/isolation/plugin-pool.d.ts

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