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

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();
-}