nx 20.4.0-canary.20250108-7f2693a → 20.4.0-canary.20250110-cbfc6fe

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.4.0-canary.20250108-7f2693a",
+  "version": "20.4.0-canary.20250110-cbfc6fe",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -82,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-darwin-x64": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-freebsd-x64": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-linux-arm-gnueabihf": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-linux-arm64-gnu": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-linux-arm64-musl": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-linux-x64-gnu": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-linux-x64-musl": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-win32-arm64-msvc": "20.4.0-canary.20250108-7f2693a",
-    "@nx/nx-win32-x64-msvc": "20.4.0-canary.20250108-7f2693a"
+    "@nx/nx-darwin-arm64": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-darwin-x64": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-freebsd-x64": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-linux-arm-gnueabihf": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-linux-arm64-gnu": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-linux-arm64-musl": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-linux-x64-gnu": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-linux-x64-musl": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-win32-arm64-msvc": "20.4.0-canary.20250110-cbfc6fe",
+    "@nx/nx-win32-x64-msvc": "20.4.0-canary.20250110-cbfc6fe"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/run/run-one.js

@@ -12,6 +12,7 @@ const output_1 = require("../../utils/output");
 const configuration_1 = require("../../config/configuration");
 const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
 const graph_1 = require("../graph/graph");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
 async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
     excludeTaskDependencies: args.excludeTaskDependencies,
     loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
@@ -31,7 +32,7 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
         process.exit(0);
     }
     await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
-    const { projects } = getProjects(projectGraph, opts.project);
+    const { projects, projectName } = getProjects(projectGraph, opts.project);
     if (nxArgs.graph) {
         const projectNames = projects.map((t) => t.name);
         const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
@@ -45,22 +46,45 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
         }, projectNames);
     }
     else {
-        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, opts.project, extraTargetDependencies, extraOptions);
+        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
         process.exit(status);
     }
 }
-function getProjects(projectGraph, project) {
-    if (!projectGraph.nodes[project]) {
-        output_1.output.error({
-            title: `Cannot find project '${project}'`,
-        });
-        process.exit(1);
+function getProjects(projectGraph, projectName) {
+    if (projectGraph.nodes[projectName]) {
+        return {
+            projectName: projectName,
+            projects: [projectGraph.nodes[projectName]],
+            projectsMap: {
+                [projectName]: projectGraph.nodes[projectName],
+            },
+        };
     }
-    let projects = [projectGraph.nodes[project]];
-    let projectsMap = {
-        [project]: projectGraph.nodes[project],
-    };
-    return { projects, projectsMap };
+    else {
+        const projects = (0, find_matching_projects_1.findMatchingProjects)([projectName], projectGraph.nodes);
+        if (projects.length === 1) {
+            const projectName = projects[0];
+            const project = projectGraph.nodes[projectName];
+            return {
+                projectName,
+                projects: [project],
+                projectsMap: {
+                    [project.data.name]: project,
+                },
+            };
+        }
+        else if (projects.length > 1) {
+            output_1.output.error({
+                title: `Multiple projects matched:`,
+                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
+            });
+            process.exit(1);
+        }
+    }
+    output_1.output.error({
+        title: `Cannot find project '${projectName}'`,
+    });
+    process.exit(1);
 }
 const targetAliases = {
     b: 'build',

package/src/command-line/show/project.js

@@ -4,14 +4,32 @@ exports.showProjectHandler = showProjectHandler;
 const output_1 = require("../../utils/output");
 const project_graph_1 = require("../../project-graph/project-graph");
 const graph_1 = require("../graph/graph");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
 async function showProjectHandler(args) {
     performance.mark('code-loading:end');
     performance.measure('code-loading', 'init-local', 'code-loading:end');
     const graph = await (0, project_graph_1.createProjectGraphAsync)();
-    const node = graph.nodes[args.projectName];
+    let node = graph.nodes[args.projectName];
     if (!node) {
-        console.log(`Could not find project ${args.projectName}`);
-        process.exit(1);
+        const projects = (0, find_matching_projects_1.findMatchingProjects)([args.projectName], graph.nodes);
+        if (projects.length === 1) {
+            const projectName = projects[0];
+            node = graph.nodes[projectName];
+        }
+        else if (projects.length > 1) {
+            output_1.output.error({
+                title: `Multiple projects matched:`,
+                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
+            });
+            console.log(`Multiple projects matched:\n  ${(projects.length > 100
+                ? [...projects.slice(0, 100), '...']
+                : projects).join('  \n')}`);
+            process.exit(1);
+        }
+        else {
+            console.log(`Could not find project ${args.projectName}`);
+            process.exit(1);
+        }
     }
     if (args.json) {
         console.log(JSON.stringify(node.data));

package/src/devkit-internals.d.ts

@@ -20,7 +20,7 @@ export { hashObject } from './hasher/file-hasher';
 export { hashWithWorkspaceContext } from './utils/workspace-context';
 export { createProjectRootMappingsFromProjectConfigurations, findProjectForPath, } from './project-graph/utils/find-project-for-path';
 export { retrieveProjectConfigurations } from './project-graph/utils/retrieve-workspace-files';
-export { LoadedNxPlugin } from './project-graph/plugins/internal-api';
+export { LoadedNxPlugin } from './project-graph/plugins/loaded-nx-plugin';
 export * from './project-graph/error-types';
 export { registerTsProject } from './plugins/js/utils/register';
 export { interpolate } from './tasks-runner/utils';

package/src/devkit-internals.js

@@ -43,8 +43,8 @@ Object.defineProperty(exports, "createProjectRootMappingsFromProjectConfiguratio
 Object.defineProperty(exports, "findProjectForPath", { enumerable: true, get: function () { return find_project_for_path_1.findProjectForPath; } });
 var retrieve_workspace_files_2 = require("./project-graph/utils/retrieve-workspace-files");
 Object.defineProperty(exports, "retrieveProjectConfigurations", { enumerable: true, get: function () { return retrieve_workspace_files_2.retrieveProjectConfigurations; } });
-var internal_api_1 = require("./project-graph/plugins/internal-api");
-Object.defineProperty(exports, "LoadedNxPlugin", { enumerable: true, get: function () { return internal_api_1.LoadedNxPlugin; } });
+var loaded_nx_plugin_1 = require("./project-graph/plugins/loaded-nx-plugin");
+Object.defineProperty(exports, "LoadedNxPlugin", { enumerable: true, get: function () { return loaded_nx_plugin_1.LoadedNxPlugin; } });
 tslib_1.__exportStar(require("./project-graph/error-types"), exports);
 var register_1 = require("./plugins/js/utils/register");
 Object.defineProperty(exports, "registerTsProject", { enumerable: true, get: function () { return register_1.registerTsProject; } });

package/src/nx-cloud/update-manager.js

@@ -10,6 +10,7 @@ const debug_logger_1 = require("./debug-logger");
 const tar = require("tar-stream");
 const cache_directory_1 = require("../utils/cache-directory");
 const crypto_1 = require("crypto");
+const workspace_root_1 = require("../utils/workspace-root");
 class NxCloudEnterpriseOutdatedError extends Error {
     constructor(url) {
         super(`Nx Cloud instance hosted at ${url} is outdated`);
@@ -83,7 +84,18 @@ async function verifyOrUpdateNxCloudClient(options) {
         nxCloudClient: require(currentBundle.fullPath),
     };
 }
-const runnerBundleInstallDirectory = (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+function getBundleInstallDefaultLocation() {
+    const legacyPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'node_modules', '.cache', 'nx', 'cloud');
+    // this legacy path is used when the nx-cloud package is installed.
+    // make sure to reuse it so that we don't `require` different the client bundles
+    if ((0, fs_1.existsSync)(legacyPath)) {
+        return legacyPath;
+    }
+    else {
+        return (0, path_1.join)(cache_directory_1.cacheDir, 'cloud');
+    }
+}
+const runnerBundleInstallDirectory = getBundleInstallDefaultLocation();
 function getLatestInstalledRunnerBundle() {
     if (!(0, fs_1.existsSync)(runnerBundleInstallDirectory)) {
         (0, fs_1.mkdirSync)(runnerBundleInstallDirectory, { recursive: true });

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

@@ -1,6 +1,6 @@
 import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
-import { LoadedNxPlugin } from './plugins/internal-api';
+import type { LoadedNxPlugin } from './plugins/loaded-nx-plugin';
 import { CreateMetadataContext } from './plugins';
 import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';

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

@@ -1,4 +1,4 @@
-import { LoadedNxPlugin } from './internal-api';
-export declare function getPlugins(): Promise<LoadedNxPlugin[]>;
-export declare function getOnlyDefaultPlugins(): Promise<LoadedNxPlugin[]>;
+import type { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function getPlugins(root?: string): Promise<LoadedNxPlugin[]>;
+export declare function getOnlyDefaultPlugins(root?: string): Promise<LoadedNxPlugin[]>;
 export declare function cleanupPlugins(): void;

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

@@ -3,16 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPlugins = getPlugins;
 exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
 exports.cleanupPlugins = cleanupPlugins;
-const file_hasher_1 = require("../../hasher/file-hasher");
+const node_path_1 = require("node:path");
+const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
-const internal_api_1 = require("./internal-api");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const native_1 = require("../../native");
 const workspace_root_1 = require("../../utils/workspace-root");
+const isolation_1 = require("./isolation");
+const in_process_loader_1 = require("./in-process-loader");
+const transpiler_1 = require("./transpiler");
+/**
+ * Stuff for specified NX Plugins.
+ */
 let currentPluginsConfigurationHash;
 let loadedPlugins;
 let pendingPluginsPromise;
 let cleanup;
-async function getPlugins() {
-    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
+async function getPlugins(root = workspace_root_1.workspaceRoot) {
+    const pluginsConfiguration = (0, nx_json_1.readNxJson)(root).plugins ?? [];
     const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
     // If the plugins configuration has not changed, reuse the current plugins
     if (loadedPlugins &&
@@ -24,17 +32,23 @@ async function getPlugins() {
         pendingPluginsPromise = undefined;
         cleanup();
     }
-    pendingPluginsPromise ??= (0, internal_api_1.loadNxPlugins)(pluginsConfiguration, workspace_root_1.workspaceRoot);
+    pendingPluginsPromise ??= loadSpecifiedNxPlugins(pluginsConfiguration, root);
     currentPluginsConfigurationHash = pluginsConfigurationHash;
-    const [result, cleanupFn] = await pendingPluginsPromise;
+    const [[result, cleanupFn], defaultPlugins] = await Promise.all([
+        pendingPluginsPromise,
+        getOnlyDefaultPlugins(root),
+    ]);
     cleanup = cleanupFn;
-    loadedPlugins = result;
-    return result;
+    loadedPlugins = result.concat(defaultPlugins);
+    return loadedPlugins;
 }
+/**
+ * Stuff for default NX Plugins.
+ */
 let loadedDefaultPlugins;
 let cleanupDefaultPlugins;
 let pendingDefaultPluginPromise;
-async function getOnlyDefaultPlugins() {
+async function getOnlyDefaultPlugins(root = workspace_root_1.workspaceRoot) {
     // If the plugins configuration has not changed, reuse the current plugins
     if (loadedDefaultPlugins) {
         return loadedPlugins;
@@ -44,7 +58,7 @@ async function getOnlyDefaultPlugins() {
         pendingDefaultPluginPromise = undefined;
         cleanupDefaultPlugins();
     }
-    pendingDefaultPluginPromise ??= (0, internal_api_1.loadNxPlugins)([], workspace_root_1.workspaceRoot);
+    pendingDefaultPluginPromise ??= loadDefaultNxPlugins(workspace_root_1.workspaceRoot);
     const [result, cleanupFn] = await pendingDefaultPluginPromise;
     cleanupDefaultPlugins = cleanupFn;
     loadedPlugins = result;
@@ -53,6 +67,92 @@ async function getOnlyDefaultPlugins() {
 function cleanupPlugins() {
     pendingPluginsPromise = undefined;
     pendingDefaultPluginPromise = undefined;
-    cleanup();
-    cleanupDefaultPlugins();
+    cleanup?.();
+    cleanupDefaultPlugins?.();
+}
+/**
+ * Stuff for generic loading
+ */
+function isIsolationEnabled() {
+    // Explicitly enabled, regardless of further conditions
+    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
+        return true;
+    }
+    if (
+    // Explicitly disabled
+    process.env.NX_ISOLATE_PLUGINS === 'false' ||
+        // Isolation is disabled on WASM builds currently.
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Default value
+    return true;
+}
+const loadingMethod = isIsolationEnabled()
+    ? isolation_1.loadNxPluginInIsolation
+    : in_process_loader_1.loadNxPlugin;
+async function loadDefaultNxPlugins(root = workspace_root_1.workspaceRoot) {
+    performance.mark('loadDefaultNxPlugins:start');
+    const plugins = getDefaultPlugins(root);
+    const cleanupFunctions = [];
+    const ret = [
+        await Promise.all(plugins.map(async (plugin) => {
+            performance.mark(`Load Nx Plugin: ${plugin} - start`);
+            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
+            cleanupFunctions.push(cleanup);
+            const res = await loadedPluginPromise;
+            performance.mark(`Load Nx Plugin: ${plugin} - end`);
+            performance.measure(`Load Nx Plugin: ${plugin}`, `Load Nx Plugin: ${plugin} - start`, `Load Nx Plugin: ${plugin} - end`);
+            return res;
+        })),
+        () => {
+            for (const fn of cleanupFunctions) {
+                fn();
+            }
+            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                (0, transpiler_1.cleanupPluginTSTranspiler)();
+            }
+        },
+    ];
+    performance.mark('loadDefaultNxPlugins:end');
+    performance.measure('loadDefaultNxPlugins', 'loadDefaultNxPlugins:start', 'loadDefaultNxPlugins:end');
+    return ret;
+}
+async function loadSpecifiedNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
+    performance.mark('loadSpecifiedNxPlugins:start');
+    plugins ??= [];
+    const cleanupFunctions = [];
+    const ret = [
+        await Promise.all(plugins.map(async (plugin) => {
+            const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
+            performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
+            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
+            cleanupFunctions.push(cleanup);
+            const res = await loadedPluginPromise;
+            performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
+            performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
+            return res;
+        })),
+        () => {
+            for (const fn of cleanupFunctions) {
+                fn();
+            }
+            if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                (0, transpiler_1.cleanupPluginTSTranspiler)();
+            }
+        },
+    ];
+    performance.mark('loadSpecifiedNxPlugins:end');
+    performance.measure('loadSpecifiedNxPlugins', 'loadSpecifiedNxPlugins:start', 'loadSpecifiedNxPlugins:end');
+    return ret;
+}
+function getDefaultPlugins(root) {
+    return [
+        (0, node_path_1.join)(__dirname, '../../plugins/js'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [(0, node_path_1.join)(__dirname, '../../adapter/angular-json')]
+            : []),
+        (0, node_path_1.join)(__dirname, '../../plugins/package-json'),
+        (0, node_path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
+    ];
 }

package/src/project-graph/plugins/in-process-loader.d.ts

@@ -0,0 +1,10 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { PackageJson } from '../../utils/package-json';
+import type { PluginConfiguration } from '../../config/nx-json';
+import type { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function loadNxPlugin(plugin: PluginConfiguration, root: string): readonly [Promise<LoadedNxPlugin>, () => void];
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/in-process-loader.js

@@ -0,0 +1,60 @@
+"use strict";
+// This file contains methods and utilities that should **only** be used by the plugin worker.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPluginPackageJson = readPluginPackageJson;
+exports.loadNxPlugin = loadNxPlugin;
+exports.loadNxPluginAsync = loadNxPluginAsync;
+const installation_directory_1 = require("../../utils/installation-directory");
+const package_json_1 = require("../../utils/package-json");
+const fileutils_1 = require("../../utils/fileutils");
+const error_types_1 = require("../error-types");
+const path = require("node:path/posix");
+const load_resolved_plugin_1 = require("./load-resolved-plugin");
+const resolve_plugin_1 = require("./resolve-plugin");
+const transpiler_1 = require("./transpiler");
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+    try {
+        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
+        return {
+            json: result.packageJson,
+            path: result.path,
+        };
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const localPluginPath = (0, resolve_plugin_1.resolveLocalNxPlugin)(pluginName, projects);
+            if (localPluginPath) {
+                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                    (0, transpiler_1.registerPluginTSTranspiler)();
+                }
+                return {
+                    path: localPluginPackageJson,
+                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
+                };
+            }
+        }
+        throw e;
+    }
+}
+function loadNxPlugin(plugin, root) {
+    return [
+        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
+        () => { },
+    ];
+}
+async function loadNxPluginAsync(pluginConfiguration, paths, root) {
+    const moduleName = typeof pluginConfiguration === 'string'
+        ? pluginConfiguration
+        : pluginConfiguration.plugin;
+    try {
+        const { pluginPath, name, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, paths);
+        if (shouldRegisterTSTranspiler) {
+            (0, transpiler_1.registerPluginTSTranspiler)();
+        }
+        return (0, load_resolved_plugin_1.loadResolvedNxPluginAsync)(pluginConfiguration, pluginPath, name);
+    }
+    catch (e) {
+        throw new error_types_1.LoadPluginError(moduleName, e);
+    }
+}

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

@@ -1,3 +1,4 @@
 export * from './public-api';
-export { readPluginPackageJson, registerPluginTSTranspiler } from './loader';
+export { readPluginPackageJson } from './in-process-loader';
+export { registerPluginTSTranspiler } from './transpiler';
 export { createNodesFromFiles } from './utils';

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

@@ -4,8 +4,9 @@ exports.createNodesFromFiles = exports.registerPluginTSTranspiler = exports.read
 const tslib_1 = require("tslib");
 tslib_1.__exportStar(require("./public-api"), exports);
 // export * from './get-plugins';
-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; } });
+var in_process_loader_1 = require("./in-process-loader");
+Object.defineProperty(exports, "readPluginPackageJson", { enumerable: true, get: function () { return in_process_loader_1.readPluginPackageJson; } });
+var transpiler_1 = require("./transpiler");
+Object.defineProperty(exports, "registerPluginTSTranspiler", { enumerable: true, get: function () { return transpiler_1.registerPluginTSTranspiler; } });
 var utils_1 = require("./utils");
 Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return utils_1.createNodesFromFiles; } });

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

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

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

@@ -1,7 +1,7 @@
 import { ProjectGraph } from '../../../config/project-graph';
 import { PluginConfiguration } from '../../../config/nx-json';
 import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2 } from '../public-api';
-import { LoadedNxPlugin } from '../internal-api';
+import type { LoadedNxPlugin } from '../loaded-nx-plugin';
 import { Serializable } from 'child_process';
 import { Socket } from 'net';
 export interface PluginWorkerLoadMessage {

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

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

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

@@ -8,7 +8,7 @@ const socket_utils_1 = require("../../../daemon/socket-utils");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const messaging_1 = require("./messaging");
 const installation_directory_1 = require("../../../utils/installation-directory");
-const loader_1 = require("../loader");
+const resolve_plugin_1 = require("../resolve-plugin");
 const cleanupFunctions = new Set();
 const pluginNames = new Map();
 const PLUGIN_TIMEOUT_HINT_TEXT = 'As a last resort, you can set NX_PLUGIN_NO_TIMEOUTS=true to bypass this timeout.';
@@ -31,7 +31,7 @@ async function loadRemoteNxPlugin(plugin, root) {
         return [nxPluginWorkerCache.get(cacheKey), () => { }];
     }
     const moduleName = typeof plugin === 'string' ? plugin : plugin.plugin;
-    const { name, pluginPath, shouldRegisterTSTranspiler } = await (0, loader_1.resolveNxPlugin)(moduleName, root, (0, installation_directory_1.getNxRequirePaths)(root));
+    const { name, pluginPath, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, (0, installation_directory_1.getNxRequirePaths)(root));
     const { worker, socket } = await startPluginWorker();
     const pendingPromises = new Map();
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);

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

@@ -5,7 +5,6 @@ const serializable_error_1 = require("../../../utils/serializable-error");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
 const net_1 = require("net");
 const fs_1 = require("fs");
-const loader_1 = require("../loader");
 if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
@@ -38,7 +37,7 @@ const server = (0, net_1.createServer)((socket) => {
                     // Register the ts-transpiler if we are pointing to a
                     // plain ts file that's not part of a plugin project
                     if (shouldRegisterTSTranspiler) {
-                        (0, loader_1.registerPluginTSTranspiler)();
+                        require('../transpiler').registerPluginTSTranspiler();
                     }
                     plugin = await loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name);
                     return {

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

@@ -1,3 +1,3 @@
 import type { PluginConfiguration } from '../../config/nx-json';
-import { LoadedNxPlugin } from './internal-api';
+import { LoadedNxPlugin } from './loaded-nx-plugin';
 export declare function loadResolvedNxPluginAsync(pluginConfiguration: PluginConfiguration, pluginPath: string, name: string): Promise<LoadedNxPlugin>;

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadResolvedNxPluginAsync = loadResolvedNxPluginAsync;
-const internal_api_1 = require("./internal-api");
+const loaded_nx_plugin_1 = require("./loaded-nx-plugin");
 async function loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name) {
     const plugin = await importPluginModule(pluginPath);
     plugin.name ??= name;
-    return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+    return new loaded_nx_plugin_1.LoadedNxPlugin(plugin, pluginConfiguration);
 }
 async function importPluginModule(pluginPath) {
     const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));

package/src/project-graph/plugins/{internal-api.d.ts → loaded-nx-plugin.d.ts}

@@ -1,7 +1,7 @@
-import { PluginConfiguration } from '../../config/nx-json';
-import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, ProjectsMetadata } from './public-api';
-import { ProjectGraph } from '../../config/project-graph';
-import { RawProjectGraphDependency } from '../project-graph-builder';
+import type { ProjectGraph } from '../../config/project-graph';
+import type { PluginConfiguration } from '../../config/nx-json';
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, ProjectsMetadata } from './public-api';
 export declare class LoadedNxPlugin {
     readonly name: string;
     readonly createNodes?: [
@@ -19,9 +19,3 @@ export type CreateNodesResultWithContext = CreateNodesResult & {
     file: string;
     pluginName: string;
 };
-/**
- * Use `getPlugins` instead.
- * @deprecated Do not use this. Use `getPlugins` instead.
- */
-export declare function loadNxPlugins(plugins: PluginConfiguration[], root?: string): Promise<readonly [LoadedNxPlugin[], () => void]>;
-export declare function getDefaultPlugins(root: string): Promise<string[]>;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadedNxPlugin = void 0;
+const error_types_1 = require("../error-types");
+const utils_1 = require("./utils");
+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 && !plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodes[0],
+                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
+            ];
+        }
+        if (plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodesV2[0],
+                async (configFiles, context) => {
+                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
+            ];
+        }
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
+        }
+        if (plugin.createMetadata) {
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
+    }
+}
+exports.LoadedNxPlugin = LoadedNxPlugin;

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

@@ -0,0 +1,15 @@
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function resolveNxPlugin(moduleName: string, root: string, paths: string[]): Promise<{
+    pluginPath: string;
+    name: any;
+    shouldRegisterTSTranspiler: boolean;
+}>;
+export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+    shouldRegisterTSTranspiler: boolean;
+};

package/src/project-graph/plugins/{loader.js → resolve-plugin.js}

@@ -1,135 +1,29 @@
 "use strict";
-// This file contains methods and utilities that should **only** be used by the plugin worker.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unregisterPluginTSTranspiler = void 0;
-exports.readPluginPackageJson = readPluginPackageJson;
+exports.resolveNxPlugin = resolveNxPlugin;
 exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
-exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
 exports.getPluginPathAndName = getPluginPathAndName;
-exports.loadNxPlugin = loadNxPlugin;
-exports.resolveNxPlugin = resolveNxPlugin;
-exports.loadNxPluginAsync = loadNxPluginAsync;
-const posix_1 = require("node:path/posix");
-const installation_directory_1 = require("../../utils/installation-directory");
-const package_json_1 = require("../../utils/package-json");
+const path = require("node:path");
+const node_fs_1 = require("node:fs");
+const packages_1 = require("../../plugins/js/utils/packages");
 const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const path_1 = require("../../utils/path");
 const workspace_root_1 = require("../../utils/workspace-root");
-const node_fs_1 = require("node:fs");
-const register_1 = require("../../plugins/js/utils/register");
 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 retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
-const error_types_1 = require("../error-types");
-const path = require("node:path/posix");
-const typescript_1 = require("../../plugins/js/utils/typescript");
-const load_resolved_plugin_1 = require("./load-resolved-plugin");
-const packages_1 = require("../../plugins/js/utils/packages");
-function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+let projectsWithoutInference;
+async function resolveNxPlugin(moduleName, root, paths) {
     try {
-        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
-        return {
-            json: result.packageJson,
-            path: result.path,
-        };
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
-            if (localPluginPath) {
-                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                if (!exports.unregisterPluginTSTranspiler) {
-                    registerPluginTSTranspiler();
-                }
-                return {
-                    path: localPluginPackageJson,
-                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
-                };
-            }
-        }
-        throw e;
-    }
-}
-function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    return lookupLocalPlugin(importPath, projects, root);
-}
-exports.unregisterPluginTSTranspiler = null;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-function registerPluginTSTranspiler() {
-    // Get the first tsconfig that matches the allowed set
-    const tsConfigName = [
-        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
-        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
-    ].find((x) => (0, node_fs_1.existsSync)(x));
-    if (!tsConfigName) {
-        return;
-    }
-    const tsConfig = tsConfigName
-        ? (0, typescript_1.readTsConfig)(tsConfigName)
-        : {};
-    const cleanupFns = [
-        (0, register_1.registerTsConfigPaths)(tsConfigName),
-        (0, register_1.registerTranspiler)({
-            experimentalDecorators: true,
-            emitDecoratorMetadata: true,
-            ...tsConfig.options,
-        }, tsConfig.raw),
-    ];
-    exports.unregisterPluginTSTranspiler = () => {
-        cleanupFns.forEach((fn) => fn?.());
-    };
-}
-function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
-    if (!projectConfig) {
-        return null;
-    }
-    return { path: path.join(root, projectConfig.root), projectConfig };
-}
-let packageEntryPointsToProjectMap;
-function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const tsConfigPaths = readTsConfigPaths(root);
-    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
-    const projectRootMappings = new Map();
-    if (possibleTsPaths.length) {
-        const projectNameMap = new Map();
-        for (const projectRoot in projects) {
-            const project = projects[projectRoot];
-            projectRootMappings.set(project.root, project.name);
-            projectNameMap.set(project.name, project);
-        }
-        for (const tsConfigPath of possibleTsPaths) {
-            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
-            if (nxProject) {
-                return projectNameMap.get(nxProject);
-            }
-        }
-    }
-    packageEntryPointsToProjectMap ??=
-        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
-    if (packageEntryPointsToProjectMap[importPath]) {
-        return packageEntryPointsToProjectMap[importPath];
+        require.resolve(moduleName);
     }
-    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
-    throw new Error('Unable to resolve local plugin with import path ' + importPath);
-}
-let tsconfigPaths;
-function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
-    if (!tsconfigPaths) {
-        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
-            .map((x) => path.join(root, x))
-            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
-        if (!tsconfigPath) {
-            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
-        }
-        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
-        tsconfigPaths = compilerOptions?.paths;
+    catch {
+        // If a plugin cannot be resolved, we will need projects to resolve it
+        projectsWithoutInference ??=
+            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
     }
-    return tsconfigPaths ?? {};
+    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+    return { pluginPath, name, shouldRegisterTSTranspiler };
 }
 function readPluginMainFromProjectConfiguration(plugin) {
     const { main } = Object.values(plugin.targets).find((x) => [
@@ -144,6 +38,9 @@ function readPluginMainFromProjectConfiguration(plugin) {
         {};
     return main;
 }
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
 function getPluginPathAndName(moduleName, paths, projects, root) {
     let pluginPath;
     let shouldRegisterTSTranspiler = false;
@@ -172,43 +69,57 @@ function getPluginPathAndName(moduleName, paths, projects, root) {
         }
     }
     const packageJsonPath = path.join(pluginPath, 'package.json');
-    const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.extname)(moduleName) === x) && // Not trying to point to a ts or js file
+    const { name } = !['.ts', '.js'].some((x) => path.extname(moduleName) === x) && // Not trying to point to a ts or js file
         (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
         ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
         : { name: moduleName };
     return { pluginPath, name, shouldRegisterTSTranspiler };
 }
-let projectsWithoutInference;
-function loadNxPlugin(plugin, root) {
-    return [
-        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
-        () => { },
-    ];
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
+        return null;
+    }
+    return { path: path.join(root, projectConfig.root), projectConfig };
 }
-async function resolveNxPlugin(moduleName, root, paths) {
-    try {
-        require.resolve(moduleName);
+let packageEntryPointsToProjectMap;
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
+    const projectRootMappings = new Map();
+    if (possibleTsPaths.length) {
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
+        for (const tsConfigPath of possibleTsPaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return projectNameMap.get(nxProject);
+            }
+        }
     }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInference ??=
-            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+    packageEntryPointsToProjectMap ??=
+        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    if (packageEntryPointsToProjectMap[importPath]) {
+        return packageEntryPointsToProjectMap[importPath];
     }
-    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
-    return { pluginPath, name, shouldRegisterTSTranspiler };
+    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
+    throw new Error('Unable to resolve local plugin with import path ' + importPath);
 }
-async function loadNxPluginAsync(pluginConfiguration, paths, root) {
-    const moduleName = typeof pluginConfiguration === 'string'
-        ? pluginConfiguration
-        : pluginConfiguration.plugin;
-    try {
-        const { pluginPath, name, shouldRegisterTSTranspiler } = await resolveNxPlugin(moduleName, root, paths);
-        if (shouldRegisterTSTranspiler) {
-            registerPluginTSTranspiler();
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
         }
-        return (0, load_resolved_plugin_1.loadResolvedNxPluginAsync)(pluginConfiguration, pluginPath, name);
-    }
-    catch (e) {
-        throw new error_types_1.LoadPluginError(moduleName, e);
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
     }
+    return tsconfigPaths ?? {};
 }

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

@@ -0,0 +1,8 @@
+export declare let unregisterPluginTSTranspiler: (() => void) | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+export declare function pluginTranspilerIsRegistered(): boolean;
+export declare function cleanupPluginTSTranspiler(): void;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterPluginTSTranspiler = void 0;
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+exports.pluginTranspilerIsRegistered = pluginTranspilerIsRegistered;
+exports.cleanupPluginTSTranspiler = cleanupPluginTSTranspiler;
+const node_fs_1 = require("node:fs");
+const posix_1 = require("node:path/posix");
+const workspace_root_1 = require("../../utils/workspace-root");
+const register_1 = require("../../plugins/js/utils/register");
+const typescript_1 = require("../../plugins/js/utils/typescript");
+exports.unregisterPluginTSTranspiler = null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    // Get the first tsconfig that matches the allowed set
+    const tsConfigName = [
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+    ].find((x) => (0, node_fs_1.existsSync)(x));
+    if (!tsConfigName) {
+        return;
+    }
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfig)(tsConfigName)
+        : {};
+    const cleanupFns = [
+        (0, register_1.registerTsConfigPaths)(tsConfigName),
+        (0, register_1.registerTranspiler)({
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            ...tsConfig.options,
+        }, tsConfig.raw),
+    ];
+    exports.unregisterPluginTSTranspiler = () => {
+        cleanupFns.forEach((fn) => fn?.());
+    };
+}
+function pluginTranspilerIsRegistered() {
+    return exports.unregisterPluginTSTranspiler !== null;
+}
+function cleanupPluginTSTranspiler() {
+    (0, exports.unregisterPluginTSTranspiler)?.();
+    exports.unregisterPluginTSTranspiler = null;
+}

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

@@ -1,7 +1,7 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../config/workspace-json-project-json';
-import { LoadedNxPlugin } from '../plugins/internal-api';
+import { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 export type SourceInformation = [file: string | null, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
 export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): void;

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -1,7 +1,7 @@
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ConfigurationResult } from './project-configuration-utils';
-import { LoadedNxPlugin } from '../plugins/internal-api';
+import { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws

package/src/utils/find-matching-projects.js

@@ -112,6 +112,17 @@ function addMatchingProjectsByName(projectNames, projects, pattern, matchedProje
         return;
     }
     if (!(0, globs_1.isGlobPattern)(pattern.value)) {
+        // Custom regex that is basically \b without underscores, so "foo" pattern matches "foo_bar".
+        const regex = new RegExp(`(?<![a-zA-Z0-9])${pattern.value}(?![a-zA-Z0-9])`, 'i');
+        const matchingProjects = Object.keys(projects).filter((name) => regex.test(name));
+        for (const projectName of matchingProjects) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
         return;
     }
     const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);

package/src/utils/plugins/plugin-capabilities.js

@@ -5,7 +5,7 @@ const path_1 = require("path");
 const fileutils_1 = require("../fileutils");
 const installation_directory_1 = require("../installation-directory");
 const plugins_1 = require("../../project-graph/plugins");
-const loader_1 = require("../../project-graph/plugins/loader");
+const in_process_loader_1 = require("../../project-graph/plugins/in-process-loader");
 function tryGetCollection(packageJsonPath, collectionFile, propName) {
     if (!collectionFile) {
         return null;
@@ -61,7 +61,7 @@ async function tryGetModule(packageJson, workspaceRoot) {
             packageJson['nx-migrations'] ??
             packageJson['schematics'] ??
             packageJson['builders']) {
-            const [pluginPromise] = (0, loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
+            const [pluginPromise] = (0, in_process_loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
             return await pluginPromise;
         }
         else {

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

@@ -1,135 +0,0 @@
-"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.LoadedNxPlugin = void 0;
-exports.loadNxPlugins = loadNxPlugins;
-exports.getDefaultPlugins = getDefaultPlugins;
-const path_1 = require("path");
-const workspace_root_1 = require("../../utils/workspace-root");
-const angular_json_1 = require("../../adapter/angular-json");
-const isolation_1 = require("./isolation");
-const loader_1 = require("./loader");
-const utils_1 = require("./utils");
-const error_types_1 = require("../error-types");
-const native_1 = require("../../native");
-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 && !plugin.createNodesV2) {
-            this.createNodes = [
-                plugin.createNodes[0],
-                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
-            ];
-        }
-        if (plugin.createNodesV2) {
-            this.createNodes = [
-                plugin.createNodesV2[0],
-                async (configFiles, context) => {
-                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
-                    return result.map((r) => [this.name, r[0], r[1]]);
-                },
-            ];
-        }
-        if (this.createNodes) {
-            const inner = this.createNodes[1];
-            this.createNodes[1] = async (...args) => {
-                performance.mark(`${plugin.name}:createNodes - start`);
-                try {
-                    return await inner(...args);
-                }
-                catch (e) {
-                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
-                        throw e;
-                    }
-                    // The underlying plugin errored out. We can't know any partial results.
-                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
-                }
-                finally {
-                    performance.mark(`${plugin.name}:createNodes - end`);
-                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
-                }
-            };
-        }
-        if (plugin.createDependencies) {
-            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
-        }
-        if (plugin.createMetadata) {
-            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
-        }
-    }
-}
-exports.LoadedNxPlugin = LoadedNxPlugin;
-function isIsolationEnabled() {
-    // Explicitly enabled, regardless of further conditions
-    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
-        return true;
-    }
-    if (
-    // Explicitly disabled
-    process.env.NX_ISOLATE_PLUGINS === 'false' ||
-        // Isolation is disabled on WASM builds currently.
-        native_1.IS_WASM) {
-        return false;
-    }
-    // Default value
-    return true;
-}
-/**
- * Use `getPlugins` instead.
- * @deprecated Do not use this. Use `getPlugins` instead.
- */
-async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
-    performance.mark('loadNxPlugins:start');
-    const loadingMethod = isIsolationEnabled()
-        ? isolation_1.loadNxPluginInIsolation
-        : loader_1.loadNxPlugin;
-    plugins = await normalizePlugins(plugins, root);
-    const cleanupFunctions = [];
-    const ret = [
-        await Promise.all(plugins.map(async (plugin) => {
-            const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
-            performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
-            const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
-            cleanupFunctions.push(cleanup);
-            const res = await loadedPluginPromise;
-            performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
-            performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
-            return res;
-        })),
-        () => {
-            for (const fn of cleanupFunctions) {
-                fn();
-            }
-            if (loader_1.unregisterPluginTSTranspiler) {
-                (0, loader_1.unregisterPluginTSTranspiler)();
-            }
-        },
-    ];
-    performance.mark('loadNxPlugins:end');
-    performance.measure('loadNxPlugins', 'loadNxPlugins:start', 'loadNxPlugins:end');
-    return ret;
-}
-async function normalizePlugins(plugins, root) {
-    plugins ??= [];
-    return [
-        ...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, angular_json_1.shouldMergeAngularProjects)(root, false)
-            ? [(0, path_1.join)(__dirname, '../../adapter/angular-json')]
-            : []),
-        (0, path_1.join)(__dirname, '../../plugins/package-json'),
-        (0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
-    ];
-}

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

@@ -1,30 +0,0 @@
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { PackageJson } from '../../utils/package-json';
-import type { PluginConfiguration } from '../../config/nx-json';
-import { LoadedNxPlugin } from './internal-api';
-export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
-    path: string;
-    json: PackageJson;
-};
-export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
-    path: string;
-    projectConfig: ProjectConfiguration;
-} | null;
-export declare let unregisterPluginTSTranspiler: (() => void) | null;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-export declare function registerPluginTSTranspiler(): void;
-export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
-    pluginPath: string;
-    name: any;
-    shouldRegisterTSTranspiler: boolean;
-};
-export declare function loadNxPlugin(plugin: PluginConfiguration, root: string): readonly [Promise<LoadedNxPlugin>, () => void];
-export declare function resolveNxPlugin(moduleName: string, root: string, paths: string[]): Promise<{
-    pluginPath: string;
-    name: any;
-    shouldRegisterTSTranspiler: boolean;
-}>;
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string): Promise<LoadedNxPlugin>;