nx 19.8.12 → 19.8.14

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": "19.8.12",
+  "version": "19.8.14",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -67,7 +67,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.8.12"
+    "@nrwl/tao": "19.8.14"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -82,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.8.12",
-    "@nx/nx-darwin-arm64": "19.8.12",
-    "@nx/nx-linux-x64-gnu": "19.8.12",
-    "@nx/nx-linux-x64-musl": "19.8.12",
-    "@nx/nx-win32-x64-msvc": "19.8.12",
-    "@nx/nx-linux-arm64-gnu": "19.8.12",
-    "@nx/nx-linux-arm64-musl": "19.8.12",
-    "@nx/nx-linux-arm-gnueabihf": "19.8.12",
-    "@nx/nx-win32-arm64-msvc": "19.8.12",
-    "@nx/nx-freebsd-x64": "19.8.12"
+    "@nx/nx-darwin-x64": "19.8.14",
+    "@nx/nx-darwin-arm64": "19.8.14",
+    "@nx/nx-linux-x64-gnu": "19.8.14",
+    "@nx/nx-linux-x64-musl": "19.8.14",
+    "@nx/nx-win32-x64-msvc": "19.8.14",
+    "@nx/nx-linux-arm64-gnu": "19.8.14",
+    "@nx/nx-linux-arm64-musl": "19.8.14",
+    "@nx/nx-linux-arm-gnueabihf": "19.8.14",
+    "@nx/nx-win32-arm64-msvc": "19.8.14",
+    "@nx/nx-freebsd-x64": "19.8.14"
   },
   "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

@@ -28,7 +28,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) {
@@ -108,7 +108,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/daemon/client/client.js

@@ -408,6 +408,9 @@ class DaemonClient {
         }
     }
     async startInBackground() {
+        if (global.NX_PLUGIN_WORKER) {
+            throw new Error('Fatal Error: Something unexpected has occurred. Plugin Workers should not start a new daemon process. Please report this issue.');
+        }
         (0, node_fs_1.mkdirSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, { recursive: true });
         if (!(0, node_fs_1.existsSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE)) {
             (0, node_fs_1.writeFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, '');

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/server.js

@@ -353,6 +353,15 @@ async function startServer() {
             server.listen((0, socket_utils_1.getFullOsSocketPath)(), async () => {
                 try {
                     logger_1.serverLogger.log(`Started listening on: ${(0, socket_utils_1.getFullOsSocketPath)()}`);
+                    setInterval(() => {
+                        if ((0, cache_1.getDaemonProcessIdSync)() !== process.pid) {
+                            return (0, shutdown_utils_1.handleServerProcessTermination)({
+                                server,
+                                reason: 'this process is no longer the current daemon (native)',
+                                sockets: exports.openSockets,
+                            });
+                        }
+                    }).unref();
                     // this triggers the storage of the lock file hash
                     daemonIsOutdated();
                     if (!(0, shutdown_utils_1.getWatcherInstance)()) {

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");
@@ -41,6 +42,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;
@@ -121,7 +127,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) {
@@ -160,8 +165,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;
     }
@@ -220,6 +223,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
     }
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
     const createDependencyPlugins = plugins.filter((plugin) => (0, utils_1.isNxPluginV2)(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 {
@@ -238,6 +242,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,
@@ -263,6 +269,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 ((0, utils_1.isNxPluginV2)(plugin) && plugin.createMetadata) {
             perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
@@ -288,5 +295,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 | ProcessProjectGraphError | 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/{daemon/server/plugins.js → project-graph/plugins/get-plugins.js}

@@ -1,10 +1,11 @@
 "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("../../project-graph/plugins/internal-api");
+const internal_api_1 = require("./internal-api");
 const workspace_root_1 = require("../../utils/workspace-root");
 let currentPluginsConfigurationHash;
 let loadedPlugins;
@@ -27,6 +28,23 @@ async function getPlugins() {
     loadedPlugins = result;
     return result;
 }
+let loadedDefaultPlugins;
+let cleanupDefaultPlugins;
+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();
+    }
+    const [result, cleanupFn] = await (0, internal_api_1.loadNxPlugins)([], workspace_root_1.workspaceRoot);
+    cleanupDefaultPlugins = cleanupFn;
+    loadedPlugins = result;
+    return result;
+}
 function cleanupPlugins() {
     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

@@ -21,5 +21,9 @@ export type CreateNodesResultWithContext = CreateNodesResult & {
     pluginName: string;
 };
 export type NormalizedPlugin = NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
+/**
+ * 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

@@ -81,21 +81,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/plugin-worker.js

@@ -1,7 +1,6 @@
 "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");
@@ -10,9 +9,19 @@ if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
 global.NX_GRAPH_CREATION = true;
+global.NX_PLUGIN_WORKER = true;
+let connected = false;
 let plugin;
 const socketPath = process.argv[2];
 const server = (0, net_1.createServer)((socket) => {
+    connected = true;
+    // This handles cases where the host process was killed
+    // after the worker connected but before the worker was
+    // instructed to load the plugin.
+    const loadTimeout = setTimeout(() => {
+        console.error(`Plugin Worker exited because no plugin was loaded within 10 seconds of starting up.`);
+        process.exit(1);
+    }, 10000).unref();
     socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
         const message = JSON.parse(raw.toString());
         if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
@@ -20,9 +29,12 @@ const server = (0, net_1.createServer)((socket) => {
         }
         return (0, messaging_1.consumeMessage)(socket, message, {
             load: async ({ plugin: pluginConfiguration, root }) => {
+                if (loadTimeout)
+                    clearTimeout(loadTimeout);
                 process.chdir(root);
                 try {
-                    const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
+                    const { loadNxPlugin } = await Promise.resolve().then(() => require('../loader'));
+                    const [promise] = loadNxPlugin(pluginConfiguration, root);
                     plugin = await promise;
                     return {
                         type: 'load-result',
@@ -131,6 +143,8 @@ const server = (0, net_1.createServer)((socket) => {
     // since the worker is spawned per host process. As such,
     // we can safely close the worker when the host disconnects.
     socket.on('end', () => {
+        // Destroys the socket once it's fully closed.
+        socket.destroySoon();
         // Stops accepting new connections, but existing connections are
         // not closed immediately.
         server.close(() => {
@@ -140,11 +154,15 @@ const server = (0, net_1.createServer)((socket) => {
             catch (e) { }
             process.exit(0);
         });
-        // Destroys the socket once it's fully closed.
-        socket.destroySoon();
     });
 });
 server.listen(socketPath);
+setTimeout(() => {
+    if (!connected) {
+        console.error('The plugin worker is exiting as it was not connected to within 5 seconds.');
+        process.exit(1);
+    }
+}, 5000).unref();
 const exitHandler = (exitCode) => () => {
     server.close();
     try {

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;

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

@@ -196,12 +196,9 @@ async function loadNxPluginAsync(pluginConfiguration, paths, root) {
             projectsWithoutInference ??=
                 await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
         }
-        performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-        let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+        const { pluginPath, name } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
         const plugin = (0, utils_1.normalizeNxPlugin)(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);
     }
     catch (e) {

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