nx 20.2.0-canary.20241203-6b87005 → 20.2.0-canary.20241205-15060e3

package/src/core/graph/styles.js

@@ -1 +1 @@
-"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{15894:()=>{}},s=>{var e;e=15894,s(s.s=e)}]);
+"use strict";(self.webpackChunk=self.webpackChunk||[]).push([[532],{24258:()=>{}},s=>{var e;e=24258,s(s.s=e)}]);

package/src/daemon/server/project-graph-incremental-recomputation.js

@@ -16,8 +16,8 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const logger_1 = require("./logger");
-const plugins_1 = require("./plugins");
 const error_types_1 = require("../../project-graph/error-types");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 let cachedSerializedProjectGraphPromise;
 const collectedUpdatedFiles = new Set();
 const collectedDeletedFiles = new Set();
@@ -38,7 +38,7 @@ async function getCachedSerializedProjectGraphPromise() {
         // reset the wait time
         waitPeriod = 100;
         await resetInternalStateIfNxDepsMissing();
-        const plugins = await (0, plugins_1.getPlugins)();
+        const plugins = await (0, get_plugins_1.getPlugins)();
         if (collectedUpdatedFiles.size == 0 && collectedDeletedFiles.size == 0) {
             if (!cachedSerializedProjectGraphPromise) {
                 cachedSerializedProjectGraphPromise =
@@ -90,7 +90,7 @@ function addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles) {
                 waitPeriod = waitPeriod * 2;
             }
             cachedSerializedProjectGraphPromise =
-                processFilesAndCreateAndSerializeProjectGraph(await (0, plugins_1.getPlugins)());
+                processFilesAndCreateAndSerializeProjectGraph(await (0, get_plugins_1.getPlugins)());
             const { projectGraph } = await cachedSerializedProjectGraphPromise;
             if (createdFiles.length > 0) {
                 (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, null, null);
@@ -238,7 +238,7 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
         const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
         const allWorkspaceFiles = copyFileData(exports.fileMapWithFiles.allWorkspaceFiles);
         const rustReferences = exports.fileMapWithFiles.rustReferences;
-        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, plugins_1.getPlugins)(), sourceMaps);
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, get_plugins_1.getPlugins)(), sourceMaps);
         exports.currentProjectFileMapCache = projectFileMapCache;
         exports.currentProjectGraph = projectGraph;
         perf_hooks_1.performance.mark('create-project-graph-end');

package/src/daemon/server/shutdown-utils.js

@@ -13,9 +13,9 @@ const workspace_root_1 = require("../../utils/workspace-root");
 const logger_1 = require("./logger");
 const socket_utils_1 = require("../socket-utils");
 const cache_1 = require("../cache");
-const plugins_1 = require("./plugins");
 const error_types_1 = require("../../project-graph/error-types");
 const db_connection_1 = require("../../utils/db-connection");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 exports.SERVER_INACTIVITY_TIMEOUT_MS = 10800000; // 10800000 ms = 3 hours
 let watcherInstance;
 function storeWatcherInstance(instance) {
@@ -50,7 +50,7 @@ async function handleServerProcessTermination({ server, reason, sockets, }) {
             logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (outputs)`);
         }
         (0, cache_1.deleteDaemonJsonProcessCache)();
-        (0, plugins_1.cleanupPlugins)();
+        (0, get_plugins_1.cleanupPlugins)();
         (0, db_connection_1.removeDbConnections)();
         logger_1.serverLogger.log(`Server stopped because: "${reason}"`);
     }

package/src/executors/utils/convert-nx-executor.js

@@ -7,7 +7,7 @@ exports.convertNxExecutor = convertNxExecutor;
 const nx_json_1 = require("../../config/nx-json");
 const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
 const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
-const internal_api_1 = require("../../project-graph/plugins/internal-api");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
 /**
  * Convert an Nx Executor into an Angular Devkit Builder
  *
@@ -17,12 +17,11 @@ function convertNxExecutor(executor) {
     const builderFunction = (options, builderContext) => {
         const promise = async () => {
             const nxJsonConfiguration = (0, nx_json_1.readNxJson)(builderContext.workspaceRoot);
-            const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJsonConfiguration.plugins, builderContext.workspaceRoot);
+            const plugins = await (0, get_plugins_1.getPlugins)();
             const projectsConfigurations = {
                 version: 2,
                 projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
             };
-            cleanup();
             const context = {
                 root: builderContext.workspaceRoot,
                 projectName: builderContext.target.project,

package/src/plugins/package-json/create-nodes.d.ts

@@ -2,13 +2,12 @@ import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PackageJson } from '../../utils/package-json';
 import { CreateNodesV2 } from '../../project-graph/plugins';
+import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
 export declare const createNodesV2: CreateNodesV2;
 export declare function buildPackageJsonWorkspacesMatcher(workspaceRoot: string, readJson: (string: any) => any): (p: string) => boolean;
-export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string): {
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache): {
     projects: {
-        [x: string]: ProjectConfiguration & {
-            name: string;
-        };
+        [x: string]: ProjectConfiguration;
     };
 };
 export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {

package/src/plugins/package-json/create-nodes.js

@@ -18,6 +18,8 @@ const package_json_1 = require("../../utils/package-json");
 const path_1 = require("../../utils/path");
 const plugins_1 = require("../../project-graph/plugins");
 const path_2 = require("path");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const package_json_2 = require("../../../plugins/package-json");
 exports.createNodesV2 = [
     (0, globs_1.combineGlobPatterns)('package.json', '**/package.json', 'project.json', '**/project.json'),
     (configFiles, _, context) => {
@@ -27,13 +29,14 @@ exports.createNodesV2 = [
         const isNextToProjectJson = (packageJsonPath) => {
             return projectJsonRoots.has((0, node_path_1.dirname)(packageJsonPath));
         };
+        const cache = (0, package_json_2.readPackageJsonConfigurationCache)();
         return (0, plugins_1.createNodesFromFiles)((packageJsonPath, options, context) => {
             if (!isInPackageJsonWorkspaces(packageJsonPath) &&
                 !isNextToProjectJson(packageJsonPath)) {
                 // Skip if package.json is not part of the package.json workspaces and not next to a project.json.
                 return null;
             }
-            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot);
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache);
         }, packageJsons, _, context);
     },
 ];
@@ -75,9 +78,23 @@ function buildPackageJsonWorkspacesMatcher(workspaceRoot, readJson) {
          */
         negativePatterns.every((negative) => (0, minimatch_1.minimatch)(p, negative));
 }
-function createNodeFromPackageJson(pkgJsonPath, workspaceRoot) {
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
+    const projectRoot = (0, node_path_1.dirname)(pkgJsonPath);
+    const hash = (0, file_hasher_1.hashObject)({
+        ...json,
+        root: projectRoot,
+    });
+    const cached = cache[hash];
+    if (cached) {
+        return {
+            projects: {
+                [cached.root]: cached,
+            },
+        };
+    }
     const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot));
+    cache[hash] = project;
     return {
         projects: {
             [project.root]: project,

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

@@ -17,7 +17,10 @@ async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.
     ];
     const touchedProjects = [];
     for (const locator of touchedProjectLocators) {
+        performance.mark(locator.name + ':start');
         const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph);
+        performance.mark(locator.name + ':end');
+        performance.measure(locator.name, locator.name + ':start', locator.name + ':end');
         touchedProjects.push(...projects);
     }
     return filterAffectedProjects(graph, {

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

@@ -6,11 +6,23 @@ const workspace_root_1 = require("../../../utils/workspace-root");
 const path_1 = require("path");
 const fs_1 = require("fs");
 const retrieve_workspace_files_1 = require("../../utils/retrieve-workspace-files");
-const internal_api_1 = require("../../plugins/internal-api");
 const globs_1 = require("../../../utils/globs");
-const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes, nxJson) => {
-    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 get_plugins_1 = require("../../plugins/get-plugins");
+const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGraphNodes) => {
+    const globPattern = await (async () => {
+        // TODO: We need a quicker way to get patterns that should not
+        // require starting up plugin workers
+        if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
+            return (0, globs_1.combineGlobPatterns)([
+                '**/package.json',
+                '**/project.json',
+                'project.json',
+                'package.json',
+            ]);
+        }
+        const plugins = await (0, get_plugins_1.getPlugins)();
+        return (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

@@ -12,6 +12,7 @@ export declare function getFileMap(): {
     allWorkspaceFiles: FileData[];
     rustReferences: NxWorkspaceFilesExternals | null;
 };
+export declare function hydrateFileMap(fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals): void;
 export declare function buildProjectGraphUsingProjectFileMap(projectRootMap: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null, plugins: LoadedNxPlugin[], sourceMap: ConfigurationSourceMaps): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFileMap = getFileMap;
+exports.hydrateFileMap = hydrateFileMap;
 exports.buildProjectGraphUsingProjectFileMap = buildProjectGraphUsingProjectFileMap;
 exports.applyProjectMetadata = applyProjectMetadata;
 const workspace_root_1 = require("../utils/workspace-root");
@@ -39,6 +40,11 @@ function getFileMap() {
         };
     }
 }
+function hydrateFileMap(fileMap, allWorkspaceFiles, rustReferences) {
+    storedFileMap = fileMap;
+    storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
+}
 async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
     storedFileMap = fileMap;
     storedAllWorkspaceFiles = allWorkspaceFiles;
@@ -119,7 +125,6 @@ function readCombinedDeps() {
     };
 }
 async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion, plugins, sourceMap) {
-    perf_hooks_1.performance.mark('build project graph:start');
     const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
     builder.setVersion(projectGraphVersion);
     for (const node in knownExternalNodes) {
@@ -158,8 +163,6 @@ async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFile
     }
     (0, implicit_project_dependencies_1.applyImplicitDependencies)(ctx.projects, updatedBuilder);
     const finalGraph = updatedBuilder.getUpdatedProjectGraph();
-    perf_hooks_1.performance.mark('build project graph:end');
-    perf_hooks_1.performance.measure('build project graph', 'build project graph:start', 'build project graph:end');
     if (!error) {
         return finalGraph;
     }
@@ -182,6 +185,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
     const errors = [];
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
     const createDependencyPlugins = plugins.filter((plugin) => plugin.createDependencies);
+    perf_hooks_1.performance.mark('createDependencies:start');
     await Promise.all(createDependencyPlugins.map(async (plugin) => {
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
         try {
@@ -200,6 +204,8 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - end`);
         perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, `${plugin.name}:createDependencies - start`, `${plugin.name}:createDependencies - end`);
     }));
+    perf_hooks_1.performance.mark('createDependencies:end');
+    perf_hooks_1.performance.measure(`createDependencies`, `createDependencies:start`, `createDependencies:end`);
     const graphWithDeps = builder.getUpdatedProjectGraph();
     const { errors: metadataErrors, graph: updatedGraph } = await applyProjectMetadata(graphWithDeps, plugins, {
         nxJsonConfiguration: context.nxJsonConfiguration,
@@ -225,6 +231,7 @@ function readRootTsConfig() {
 async function applyProjectMetadata(graph, plugins, context, sourceMap) {
     const results = [];
     const errors = [];
+    perf_hooks_1.performance.mark('createMetadata:start');
     const promises = plugins.map(async (plugin) => {
         if (plugin.createMetadata) {
             perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
@@ -250,5 +257,7 @@ async function applyProjectMetadata(graph, plugins, context, sourceMap) {
             }
         }
     }
+    perf_hooks_1.performance.mark('createMetadata:end');
+    perf_hooks_1.performance.measure(`createMetadata`, `createMetadata:start`, `createMetadata:end`);
     return { errors, graph };
 }

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

@@ -1,7 +1,7 @@
 import { ConfigurationResult, ConfigurationSourceMaps } from './utils/project-configuration-utils';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { ProjectGraph } from '../config/project-graph';
-import { CreateNodesFunctionV2 } from './plugins';
+import { CreateNodesFunctionV2 } from './plugins/public-api';
 export declare class ProjectGraphError extends Error {
     #private;
     constructor(errors: Array<AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlugins = getPlugins;
+exports.getOnlyDefaultPlugins = getOnlyDefaultPlugins;
+exports.cleanupPlugins = cleanupPlugins;
+const file_hasher_1 = require("../../hasher/file-hasher");
+const nx_json_1 = require("../../config/nx-json");
+const internal_api_1 = require("./internal-api");
+const workspace_root_1 = require("../../utils/workspace-root");
+let currentPluginsConfigurationHash;
+let loadedPlugins;
+let pendingPluginsPromise;
+let cleanup;
+async function getPlugins() {
+    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
+    const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
+    // If the plugins configuration has not changed, reuse the current plugins
+    if (loadedPlugins &&
+        pluginsConfigurationHash === currentPluginsConfigurationHash) {
+        return loadedPlugins;
+    }
+    // Cleanup current plugins before loading new ones
+    if (cleanup) {
+        cleanup();
+    }
+    pendingPluginsPromise ??= (0, internal_api_1.loadNxPlugins)(pluginsConfiguration, workspace_root_1.workspaceRoot);
+    currentPluginsConfigurationHash = pluginsConfigurationHash;
+    const [result, cleanupFn] = await pendingPluginsPromise;
+    cleanup = cleanupFn;
+    loadedPlugins = result;
+    return result;
+}
+let loadedDefaultPlugins;
+let cleanupDefaultPlugins;
+let pendingDefaultPluginPromise;
+async function getOnlyDefaultPlugins() {
+    // If the plugins configuration has not changed, reuse the current plugins
+    if (loadedDefaultPlugins) {
+        return loadedPlugins;
+    }
+    // Cleanup current plugins before loading new ones
+    if (cleanupDefaultPlugins) {
+        cleanupDefaultPlugins();
+    }
+    pendingDefaultPluginPromise ??= (0, internal_api_1.loadNxPlugins)([], workspace_root_1.workspaceRoot);
+    const [result, cleanupFn] = await pendingDefaultPluginPromise;
+    cleanupDefaultPlugins = cleanupFn;
+    loadedPlugins = result;
+    return result;
+}
+function cleanupPlugins() {
+    pendingPluginsPromise = undefined;
+    pendingDefaultPluginPromise = undefined;
+    cleanup();
+    cleanupDefaultPlugins();
+}

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNodesFromFiles = exports.registerPluginTSTranspiler = exports.readPluginPackageJson = void 0;
 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; } });

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

@@ -18,5 +18,9 @@ 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/internal-api.js

@@ -80,21 +80,28 @@ function isIsolationEnabled() {
     // 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 result = new Array(plugins?.length);
     const cleanupFunctions = [];
-    await Promise.all(plugins.map(async (plugin, idx) => {
-        const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
-        result[idx] = loadedPluginPromise;
-        cleanupFunctions.push(cleanup);
-    }));
     const ret = [
-        await Promise.all(result),
+        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();

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

@@ -4,11 +4,5 @@ exports.loadNxPluginInIsolation = loadNxPluginInIsolation;
 const workspace_root_1 = require("../../../utils/workspace-root");
 const plugin_pool_1 = require("./plugin-pool");
 async function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
-    const [loadingPlugin, cleanup] = await (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-    return [
-        loadingPlugin,
-        () => {
-            cleanup();
-        },
-    ];
+    return (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
 }

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

@@ -9,6 +9,9 @@ export interface PluginWorkerLoadMessage {
     payload: {
         plugin: PluginConfiguration;
         root: string;
+        name: string;
+        pluginPath: string;
+        shouldRegisterTSTranspiler: boolean;
     };
 }
 export interface PluginWorkerLoadResult {

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

@@ -7,6 +7,8 @@ const net_1 = require("net");
 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 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.';
@@ -28,6 +30,8 @@ async function loadRemoteNxPlugin(plugin, root) {
     if (nxPluginWorkerCache.has(cacheKey)) {
         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 { worker, socket } = await startPluginWorker();
     const pendingPromises = new Map();
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
@@ -40,7 +44,7 @@ async function loadRemoteNxPlugin(plugin, root) {
     const pluginPromise = new Promise((res, rej) => {
         (0, messaging_1.sendMessageOverSocket)(socket, {
             type: 'load',
-            payload: { plugin, root },
+            payload: { plugin, root, name, pluginPath, shouldRegisterTSTranspiler },
         });
         // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
         const loadTimeout = setTimeout(() => {

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

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
-const loader_1 = require("../loader");
 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');
 }
@@ -29,13 +29,18 @@ const server = (0, net_1.createServer)((socket) => {
             return;
         }
         return (0, messaging_1.consumeMessage)(socket, message, {
-            load: async ({ plugin: pluginConfiguration, root }) => {
+            load: async ({ plugin: pluginConfiguration, root, name, pluginPath, shouldRegisterTSTranspiler, }) => {
                 if (loadTimeout)
                     clearTimeout(loadTimeout);
                 process.chdir(root);
                 try {
-                    const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
-                    plugin = await promise;
+                    const { loadResolvedNxPluginAsync } = await Promise.resolve().then(() => require('../load-resolved-plugin'));
+                    // Register the ts-transpiler if we are pointing to a
+                    // plain ts file that's not part of a plugin project
+                    if (shouldRegisterTSTranspiler) {
+                        (0, loader_1.registerPluginTSTranspiler)();
+                    }
+                    plugin = await loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name);
                     return {
                         type: 'load-result',
                         payload: {

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

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

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResolvedNxPluginAsync = loadResolvedNxPluginAsync;
+const internal_api_1 = require("./internal-api");
+async function loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name) {
+    const plugin = await importPluginModule(pluginPath);
+    plugin.name ??= name;
+    return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+}
+async function importPluginModule(pluginPath) {
+    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
+    if (m.default &&
+        ('createNodes' in m.default ||
+            'createNodesV2' in m.default ||
+            'createDependencies' in m.default)) {
+        return m.default;
+    }
+    return m;
+}

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

@@ -1,6 +1,6 @@
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PackageJson } from '../../utils/package-json';
-import { PluginConfiguration } from '../../config/nx-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;
@@ -19,6 +19,12 @@ 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>;