nx 20.2.0-beta.5 → 20.2.0-beta.7

package/bin/post-install.js

@@ -18,10 +18,12 @@ const workspace_context_1 = require("../src/utils/workspace-context");
         if (isMainNxPackage() && (0, fileutils_1.fileExists)((0, path_1.join)(workspace_root_1.workspaceRoot, 'nx.json'))) {
             (0, assert_supported_platform_1.assertSupportedPlatform)();
             (0, workspace_context_1.setupWorkspaceContext)(workspace_root_1.workspaceRoot);
-            try {
-                await client_1.daemonClient.stop();
+            if (client_1.daemonClient.enabled()) {
+                try {
+                    await client_1.daemonClient.stop();
+                }
+                catch (e) { }
             }
-            catch (e) { }
             const tasks = [
                 (0, project_graph_1.buildProjectGraphAndSourceMapsWithoutDaemon)(),
             ];

package/package.json

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

package/plugins/package-json.d.ts

@@ -1 +1,5 @@
-export {};
+import { ProjectConfiguration } from '../src/config/workspace-json-project-json';
+export type PackageJsonConfigurationCache = {
+    [hash: string]: ProjectConfiguration;
+};
+export declare function readPackageJsonConfigurationCache(): PackageJsonConfigurationCache;

package/plugins/package-json.js

@@ -1,12 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPackageJsonConfigurationCache = readPackageJsonConfigurationCache;
+const plugins_1 = require("../src/project-graph/plugins");
 const workspace_root_1 = require("../src/utils/workspace-root");
 const package_json_1 = require("../src/plugins/package-json");
+const cache_directory_1 = require("../src/utils/cache-directory");
+const path_1 = require("path");
+const fileutils_1 = require("../src/utils/fileutils");
+const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'package-json.hash');
+function readPackageJsonConfigurationCache() {
+    try {
+        return (0, fileutils_1.readJsonFile)(cachePath);
+    }
+    catch (e) {
+        return {};
+    }
+}
+function writeCache(cache) {
+    (0, fileutils_1.writeJsonFile)(cachePath, cache);
+}
 const plugin = {
     name: 'nx-all-package-jsons-plugin',
-    createNodes: [
+    createNodesV2: [
         '*/**/package.json',
-        (f) => (0, package_json_1.createNodeFromPackageJson)(f, workspace_root_1.workspaceRoot),
+        (configFiles, options, context) => {
+            const cache = readPackageJsonConfigurationCache();
+            const result = (0, plugins_1.createNodesFromFiles)((f) => (0, package_json_1.createNodeFromPackageJson)(f, workspace_root_1.workspaceRoot, cache), configFiles, options, context);
+            writeCache(cache);
+            return result;
+        },
     ],
 };
 module.exports = plugin;
+module.exports.readPackageJsonConfigurationCache =
+    readPackageJsonConfigurationCache;

package/src/command-line/affected/affected.js

@@ -26,7 +26,9 @@ async function affected(command, args, extraTargetDependencies = {}, extraOption
         printWarnings: command !== 'print-affected' && !args.plain && args.graph !== 'stdout',
     }, nxJson);
     await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({
+        exitOnError: true,
+    });
     const projects = await getAffectedGraphNodes(nxArgs, projectGraph);
     try {
         switch (command) {

package/src/command-line/format/format.js

@@ -34,7 +34,7 @@ async function format(command, args) {
     const patterns = (await getPatterns({ ...args, ...nxArgs })).map(
     // prettier removes one of the \
     // prettier-ignore
-    (p) => `"${p.replace(/\$/g, "\\\$")}"`);
+    (p) => `"${p.replace(/\$/g, '\\\$')}"`);
     // Chunkify the patterns array to prevent crashing the windows terminal
     const chunkList = (0, chunkify_1.chunkify)(patterns);
     switch (command) {
@@ -110,7 +110,9 @@ async function getPatterns(args) {
     }
 }
 async function getPatternsFromApps(affectedFiles, allWorkspaceFiles, projectGraph) {
-    const graph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const graph = await (0, project_graph_1.createProjectGraphAsync)({
+        exitOnError: true,
+    });
     const affectedGraph = await (0, affected_project_graph_1.filterAffected)(graph, (0, file_utils_1.calculateFileChanges)(affectedFiles, allWorkspaceFiles));
     return getPatternsFromProjects(Object.keys(affectedGraph.nodes), projectGraph);
 }

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

@@ -5,6 +5,8 @@ const output_1 = require("../../utils/output");
 const project_graph_1 = require("../../project-graph/project-graph");
 const graph_1 = require("../graph/graph");
 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];
     if (!node) {
@@ -56,5 +58,7 @@ async function showProjectHandler(args) {
             }
         }
     }
+    // TODO: Find a better fix for this
+    await new Promise((res) => setImmediate(res));
     await output_1.output.drain();
 }

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

@@ -11,6 +11,8 @@ const all_file_data_1 = require("../../utils/all-file-data");
 const command_line_utils_1 = require("../../utils/command-line-utils");
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 async function showProjectsHandler(args) {
+    performance.mark('code-loading:end');
+    performance.measure('code-loading', 'init-local', 'code-loading:end');
     let graph = await (0, project_graph_1.createProjectGraphAsync)();
     const nxJson = (0, nx_json_1.readNxJson)();
     const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
@@ -59,6 +61,8 @@ async function showProjectsHandler(args) {
             console.log(project);
         }
     }
+    // TODO: Find a better fix for this
+    await new Promise((res) => setImmediate(res));
     await output_1.output.drain();
 }
 function getGraphNodesMatchingPatterns(graph, patterns) {

package/src/command-line/sync/sync.js

@@ -29,7 +29,7 @@ function syncHandler(options) {
                 title: options.check
                     ? 'The workspace is up to date'
                     : 'The workspace is already up to date',
-                bodyLines: syncGenerators.map((generator) => `The ${chalk.bold(generator)} sync generator didn't identify any files in the workspace that are out of sync.`),
+                bodyLines: syncGenerators.map((generator) => `[${chalk.bold(generator)}]: All files are up to date.`),
             });
             return 0;
         }
@@ -85,9 +85,9 @@ function syncHandler(options) {
                     'Syncing the workspace failed with the following error:',
                     '',
                     e.message,
-                    ...(options.verbose && !!e.stack ? [`\n${e.stack}`] : []),
+                    ...(!!e.stack ? [`\n${e.stack}`] : []),
                     '',
-                    'Please rerun with `--verbose` and report the error at: https://github.com/nrwl/nx/issues/new/choose',
+                    'Please report the error at: https://github.com/nrwl/nx/issues/new/choose',
                 ],
             });
             return 1;

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>;

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

@@ -7,6 +7,7 @@ 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");
@@ -20,10 +21,10 @@ 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 internal_api_1 = require("./internal-api");
 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");
 function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
@@ -138,19 +139,19 @@ function readPluginMainFromProjectConfiguration(plugin) {
 }
 function getPluginPathAndName(moduleName, paths, projects, root) {
     let pluginPath;
-    let registerTSTranspiler = false;
+    let shouldRegisterTSTranspiler = false;
     try {
         pluginPath = require.resolve(moduleName, {
             paths,
         });
         const extension = path.extname(pluginPath);
-        registerTSTranspiler = extension === '.ts';
+        shouldRegisterTSTranspiler = extension === '.ts';
     }
     catch (e) {
         if (e.code === 'MODULE_NOT_FOUND') {
             const plugin = resolveLocalNxPlugin(moduleName, projects, root);
             if (plugin) {
-                registerTSTranspiler = true;
+                shouldRegisterTSTranspiler = true;
                 const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
                 pluginPath = main ? path.join(root, main) : plugin.path;
             }
@@ -164,16 +165,11 @@ function getPluginPathAndName(moduleName, paths, projects, root) {
         }
     }
     const packageJsonPath = path.join(pluginPath, 'package.json');
-    // Register the ts-transpiler if we are pointing to a
-    // plain ts file that's not part of a plugin project
-    if (registerTSTranspiler) {
-        registerPluginTSTranspiler();
-    }
     const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.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 };
+    return { pluginPath, name, shouldRegisterTSTranspiler };
 }
 let projectsWithoutInference;
 function loadNxPlugin(plugin, root) {
@@ -182,38 +178,30 @@ function loadNxPlugin(plugin, root) {
         () => { },
     ];
 }
+async function resolveNxPlugin(moduleName, root, paths) {
+    try {
+        require.resolve(moduleName);
+    }
+    catch {
+        // If a plugin cannot be resolved, we will need projects to resolve it
+        projectsWithoutInference ??=
+            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+    }
+    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+    return { pluginPath, name, shouldRegisterTSTranspiler };
+}
 async function loadNxPluginAsync(pluginConfiguration, paths, root) {
     const moduleName = typeof pluginConfiguration === 'string'
         ? pluginConfiguration
         : pluginConfiguration.plugin;
     try {
-        try {
-            require.resolve(moduleName);
-        }
-        catch {
-            // If a plugin cannot be resolved, we will need projects to resolve it
-            projectsWithoutInference ??=
-                await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+        const { pluginPath, name, shouldRegisterTSTranspiler } = await resolveNxPlugin(moduleName, root, paths);
+        if (shouldRegisterTSTranspiler) {
+            registerPluginTSTranspiler();
         }
-        performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-        const { pluginPath, name } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
-        const plugin = await importPluginModule(pluginPath);
-        plugin.name ??= name;
-        performance.mark(`Load Nx Plugin: ${moduleName} - end`);
-        performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
-        return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+        return (0, load_resolved_plugin_1.loadResolvedNxPluginAsync)(pluginConfiguration, pluginPath, name);
     }
     catch (e) {
         throw new error_types_1.LoadPluginError(moduleName, e);
     }
 }
-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/project-graph.js

@@ -18,8 +18,9 @@ const workspace_root_1 = require("../utils/workspace-root");
 const build_project_graph_1 = require("./build-project-graph");
 const error_types_1 = require("./error-types");
 const nx_deps_cache_1 = require("./nx-deps-cache");
-const internal_api_1 = require("./plugins/internal-api");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
+const get_plugins_1 = require("./plugins/get-plugins");
+const logger_1 = require("../utils/logger");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -75,7 +76,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;
-    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson.plugins);
+    const plugins = await (0, get_plugins_1.getPlugins)();
     try {
         configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
     }
@@ -112,15 +113,6 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
             throw e;
         }
     }
-    finally {
-        // When plugins are isolated we don't clean them up during
-        // a single run of the CLI. They are cleaned up when the CLI
-        // process exits. Cleaning them here could cause issues if pending
-        // promises are not resolved.
-        if (process.env.NX_ISOLATE_PLUGINS !== 'true') {
-            cleanup();
-        }
-    }
     const { projectGraph, projectFileMapCache } = projectGraphResult;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
     delete global.NX_GRAPH_CREATION;
@@ -195,6 +187,22 @@ async function createProjectGraphAsync(opts = {
     exitOnError: false,
     resetDaemonClient: false,
 }) {
+    if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
+        try {
+            const graph = readCachedProjectGraph();
+            const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
+                data.root,
+                project,
+            ]));
+            const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+            (0, build_project_graph_1.hydrateFileMap)(fileMap, allWorkspaceFiles, rustReferences);
+            return graph;
+            // If no cached graph is found, we will fall through to the normal flow
+        }
+        catch (e) {
+            logger_1.logger.verbose('Unable to use cached project graph', e);
+        }
+    }
     const projectGraphAndSourceMaps = await createProjectGraphAndSourceMapsAsync(opts);
     return projectGraphAndSourceMaps.projectGraph;
 }

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

@@ -21,10 +21,6 @@ export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRoo
  */
 export declare function retrieveProjectConfigurations(plugins: LoadedNxPlugin[], workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
 export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
-export declare function retrieveProjectConfigurationPaths(root: string, plugins: Array<{
-    createNodes?: readonly [string, ...unknown[]];
-} & unknown>): Promise<string[]>;
+export declare function retrieveProjectConfigurationPaths(root: string, plugins: Array<LoadedNxPlugin>): Promise<string[]>;
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function configurationGlobs(plugins: Array<{
-    createNodes?: readonly [string, ...unknown[]];
-}>): string[];
+export declare function configurationGlobs(plugins: Array<LoadedNxPlugin>): string[];

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -10,10 +10,10 @@ const perf_hooks_1 = require("perf_hooks");
 const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
 const project_configuration_utils_1 = require("./project-configuration-utils");
-const internal_api_1 = require("../plugins/internal-api");
 const workspace_context_1 = require("../../utils/workspace-context");
 const build_all_workspace_files_1 = require("./build-all-workspace-files");
 const path_1 = require("path");
+const get_plugins_1 = require("../plugins/get-plugins");
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -52,9 +52,8 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
             (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
         pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
     }
-    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
+    const plugins = await (0, get_plugins_1.getPlugins)();
     const res = await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
-    cleanup();
     return res;
 }
 function retrieveProjectConfigurationPaths(root, plugins) {
@@ -65,7 +64,7 @@ const projectsWithoutPluginCache = new Map();
 // TODO: This function is called way too often, it should be optimized without this cache
 async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
-    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)([]); // only load default plugins
+    const plugins = await (0, get_plugins_1.getOnlyDefaultPlugins)(); // only load default plugins
     const projectGlobPatterns = await retrieveProjectConfigurationPaths(root, plugins);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
@@ -74,7 +73,6 @@ async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const projectFiles = (await (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns)) ?? [];
     const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, plugins);
     projectsWithoutPluginCache.set(cacheKey, projects);
-    cleanup();
     return projects;
 }
 function configurationGlobs(plugins) {

package/src/tasks-runner/run-command.js

@@ -149,8 +149,8 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
     const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, nxArgs.verbose);
     const outOfSyncTitle = 'The workspace is out of sync';
     const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
-    const fixMessage = 'You can manually run `nx sync` to update your workspace with the identified changes or you can set `sync.applyChanges` to `true` in your `nx.json` to apply the changes automatically when running tasks in interactive environments.';
-    const willErrorOnCiMessage = 'Please note that having the workspace out of sync will result in an error in CI.';
+    const fixMessage = 'Make sure to run `nx sync` to apply the identified changes or set `sync.applyChanges` to `true` in your `nx.json` to apply them automatically when running tasks in interactive environments.';
+    const willErrorOnCiMessage = 'This will result in an error in CI.';
     if ((0, is_ci_1.isCI)() || !process.stdout.isTTY) {
         // If the user is running in CI or is running in a non-TTY environment we
         // throw an error to stop the execution of the tasks.

package/src/utils/sync-generators.js

@@ -145,10 +145,7 @@ function getSyncGeneratorSuccessResultsMessageLines(results) {
         if ('error' in result) {
             continue;
         }
-        messageLines.push(`The ${chalk.bold(result.generatorName)} sync generator identified ${chalk.bold(result.changes.length)} file${result.changes.length === 1 ? '' : 's'} in the workspace that ${result.changes.length === 1 ? 'is' : 'are'} out of sync${result.outOfSyncMessage ? ':' : '.'}`);
-        if (result.outOfSyncMessage) {
-            messageLines.push(result.outOfSyncMessage);
-        }
+        messageLines.push(`[${chalk.bold(result.generatorName)}]: ${result.outOfSyncMessage ?? `Some files are out of sync.`}`);
     }
     return messageLines;
 }
@@ -159,11 +156,11 @@ function getFailedSyncGeneratorsFixMessageLines(results, verbose, globalGenerato
     let isFirst = true;
     for (const result of results) {
         if ('error' in result) {
-            if (!isFirst) {
+            if (!isFirst && verbose) {
                 messageLines.push('');
             }
             isFirst = false;
-            messageLines.push(`The ${chalk.bold(result.generatorName)} sync generator reported the following error:`, '', errorToString(result.error, verbose));
+            messageLines.push(`[${chalk.bold(result.generatorName)}]: ${errorToString(result.error, verbose)}`);
             if (globalGeneratorSet.has(result.generatorName)) {
                 globalGenerators.push(result.generatorName);
             }
@@ -181,11 +178,11 @@ function getFlushFailureMessageLines(result, verbose, globalGeneratorSet = new S
     const taskGenerators = [];
     let isFirst = true;
     for (const failure of result.generatorFailures) {
-        if (!isFirst) {
+        if (!isFirst && verbose) {
             messageLines.push('');
         }
         isFirst = false;
-        messageLines.push(`The ${chalk.bold(failure.generator)} sync generator failed to apply its changes with the following error:`, '', errorToString(failure.error, verbose));
+        messageLines.push(`[${chalk.bold(failure.generator)}]: ${errorToString(failure.error, verbose)}`);
         if (globalGeneratorSet.has(failure.generator)) {
             globalGenerators.push(failure.generator);
         }
@@ -205,13 +202,11 @@ function getFlushFailureMessageLines(result, verbose, globalGeneratorSet = new S
         messageLines.push(...[
             '',
             result.generalFailure.message,
-            ...(verbose && !!result.generalFailure.stack
+            ...(!!result.generalFailure.stack
                 ? [`\n${result.generalFailure.stack}`]
                 : []),
             '',
-            verbose
-                ? 'Please report the error at: https://github.com/nrwl/nx/issues/new/choose'
-                : 'Please run with `--verbose` and report the error at: https://github.com/nrwl/nx/issues/new/choose',
+            'Please report the error at: https://github.com/nrwl/nx/issues/new/choose',
         ]);
     }
     return messageLines;
@@ -329,7 +324,7 @@ function getFailedSyncGeneratorsMessageLines(taskGenerators, globalGenerators, v
 }
 function errorToString(error, verbose) {
     if (error.title) {
-        let message = `  ${chalk.red(error.title)}`;
+        let message = `${chalk.red(error.title)}`;
         if (error.bodyLines?.length) {
             message += `
 
@@ -339,7 +334,7 @@ function errorToString(error, verbose) {
             return message;
         }
     }
-    return `  ${chalk.red(error.message)}${verbose && error.stack ? '\n  ' + error.stack : ''}`;
+    return `${chalk.red(error.message)}${verbose && error.stack ? '\n  ' + error.stack : ''}`;
 }
 function toSerializableError(error) {
     return error instanceof SyncError

package/src/daemon/server/plugins.d.ts

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

package/src/daemon/server/plugins.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPlugins = getPlugins;
-exports.cleanupPlugins = cleanupPlugins;
-const file_hasher_1 = require("../../hasher/file-hasher");
-const nx_json_1 = require("../../config/nx-json");
-const internal_api_1 = require("../../project-graph/plugins/internal-api");
-const workspace_root_1 = require("../../utils/workspace-root");
-let currentPluginsConfigurationHash;
-let loadedPlugins;
-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();
-    }
-    currentPluginsConfigurationHash = pluginsConfigurationHash;
-    const [result, cleanupFn] = await (0, internal_api_1.loadNxPlugins)(pluginsConfiguration, workspace_root_1.workspaceRoot);
-    cleanup = cleanupFn;
-    loadedPlugins = result;
-    return result;
-}
-function cleanupPlugins() {
-    cleanup();
-}