nx 22.7.0 → 23.0.0-beta.0

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

@@ -4,8 +4,9 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { AggregateCreateNodesError, MergeNodesError, MultipleProjectsWithSameNameError, ProjectsWithNoNameError, WorkspaceValidityError } from '../error-types';
 import type { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 import { CreateNodesResult } from '../plugins/public-api';
-import type { ConfigurationSourceMaps, SourceInformation } from './project-configuration/source-maps';
-export { mergeTargetConfigurations, readTargetDefaultsForTarget, } from './project-configuration/target-merging';
+import type { ConfigurationSourceMaps } from './project-configuration/source-maps';
+export { mergeTargetConfigurations } from './project-configuration/target-merging';
+export { readTargetDefaultsForTarget } from './project-configuration/target-defaults';
 export type ConfigurationResult = {
     /**
      * A map of project configurations, keyed by project root.
@@ -30,22 +31,45 @@ export type ConfigurationResult = {
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
+ * Plugins are run in parallel, then results are merged in a single ordered pass:
+ *   specified plugins → synthetic target defaults → default plugins
+ *
+ * This ordering ensures '...' spread tokens in default plugin configs
+ * (project.json, package.json) expand against accumulated values from
+ * specified plugins and target defaults.
+ *
  * @param root The workspace root
  * @param nxJson The NxJson configuration
- * @param workspaceFiles A list of non-ignored workspace files
- * @param plugins The plugins that should be used to infer project configuration
+ * @param projectFiles Plugin config files, separated by plugin set
+ * @param plugins The plugins separated into specified and default sets
  */
-export declare function createProjectConfigurationsWithPlugins(root: string, nxJson: NxJsonConfiguration, projectFiles: string[][], // making this parameter allows devkit to pick up newly created projects
-plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
-export declare function mergeCreateNodesResults(results: (readonly [
+export declare function createProjectConfigurationsWithPlugins(root: string, nxJson: NxJsonConfiguration, projectFiles: {
+    specifiedPluginFiles: string[][];
+    defaultPluginFiles: string[][];
+}, plugins: {
+    specifiedPlugins: LoadedNxPlugin[];
+    defaultPlugins: LoadedNxPlugin[];
+}): Promise<ConfigurationResult>;
+export type CreateNodesResultEntry = readonly [
     plugin: string,
     file: string,
     result: CreateNodesResult,
     pluginIndex?: number
-])[][], nxJsonConfiguration: NxJsonConfiguration, workspaceRoot: string, errors: (AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError)[]): {
+];
+export type MergeError = AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError;
+/**
+ * Merges create nodes results into a single rootMap.
+ *
+ * Default plugin results are merged twice: first into an intermediate
+ * rootMap with unresolved spread sentinels preserved, so target
+ * defaults selection sees the real merged shape of defaults; then
+ * applied as a single layer onto the main rootMap where the preserved
+ * spreads resolve against the specified + target-defaults base.
+ */
+export declare function mergeCreateNodesResults(specifiedResults: CreateNodesResultEntry[][], defaultResults: CreateNodesResultEntry[][], nxJsonConfiguration: NxJsonConfiguration, workspaceRoot: string, errors: MergeError[]): {
     projectRootMap: Record<string, ProjectConfiguration>;
     externalNodes: Record<string, ProjectGraphExternalNode>;
     rootMap: Record<string, string>;
-    configurationSourceMaps: Record<string, Record<string, SourceInformation>>;
+    configurationSourceMaps: ConfigurationSourceMaps;
 };
 export declare function findMatchingConfigFiles(projectFiles: string[], pattern: string, include: string[], exclude: string[]): string[];

package/dist/src/project-graph/utils/project-configuration-utils.js

@@ -13,35 +13,53 @@ const delayed_spinner_1 = require("../../utils/delayed-spinner");
 const plugin_progress_text_1 = require("../../utils/plugin-progress-text");
 const progress_topics_1 = require("../../utils/progress-topics");
 const error_types_1 = require("../error-types");
+const target_defaults_1 = require("./project-configuration/target-defaults");
 var target_merging_1 = require("./project-configuration/target-merging");
 Object.defineProperty(exports, "mergeTargetConfigurations", { enumerable: true, get: function () { return target_merging_1.mergeTargetConfigurations; } });
-Object.defineProperty(exports, "readTargetDefaultsForTarget", { enumerable: true, get: function () { return target_merging_1.readTargetDefaultsForTarget; } });
+var target_defaults_2 = require("./project-configuration/target-defaults");
+Object.defineProperty(exports, "readTargetDefaultsForTarget", { enumerable: true, get: function () { return target_defaults_2.readTargetDefaultsForTarget; } });
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
+ * Plugins are run in parallel, then results are merged in a single ordered pass:
+ *   specified plugins → synthetic target defaults → default plugins
+ *
+ * This ordering ensures '...' spread tokens in default plugin configs
+ * (project.json, package.json) expand against accumulated values from
+ * specified plugins and target defaults.
+ *
  * @param root The workspace root
  * @param nxJson The NxJson configuration
- * @param workspaceFiles A list of non-ignored workspace files
- * @param plugins The plugins that should be used to infer project configuration
+ * @param projectFiles Plugin config files, separated by plugin set
+ * @param plugins The plugins separated into specified and default sets
  */
-async function createProjectConfigurationsWithPlugins(root = workspace_root_1.workspaceRoot, nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
-plugins) {
+async function createProjectConfigurationsWithPlugins(root = workspace_root_1.workspaceRoot, nxJson, projectFiles, plugins) {
     perf_hooks_1.performance.mark('build-project-configs:start');
     let spinner;
     const inProgressPlugins = new Set();
     const getSpinnerText = () => spinner
         ? (0, plugin_progress_text_1.formatPluginProgressText)('Creating project graph nodes', inProgressPlugins)
         : '';
-    const createNodesPlugins = plugins.filter((plugin) => plugin.createNodes?.[0]);
+    const specifiedCreateNodesPlugins = plugins.specifiedPlugins.filter((plugin) => plugin.createNodes?.[0]);
+    const defaultCreateNodesPlugins = plugins.defaultPlugins.filter((plugin) => plugin.createNodes?.[0]);
+    const allCreateNodesPlugins = [
+        ...specifiedCreateNodesPlugins,
+        ...defaultCreateNodesPlugins,
+    ];
+    const allProjectFiles = [
+        ...projectFiles.specifiedPluginFiles,
+        ...projectFiles.defaultPluginFiles,
+    ];
+    const specifiedCount = specifiedCreateNodesPlugins.length;
     spinner = new delayed_spinner_1.DelayedSpinner(getSpinnerText(), {
         progressTopic: progress_topics_1.ProgressTopics.GraphConstruction,
     });
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const [index, { index: pluginIndex, createNodes: createNodesTuple, include, exclude, name: pluginName, },] of createNodesPlugins.entries()) {
+    for (const [index, { index: pluginIndex, createNodes: createNodesTuple, include, exclude, name: pluginName, },] of allCreateNodesPlugins.entries()) {
         const [pattern, createNodes] = createNodesTuple;
-        const matchingConfigFiles = findMatchingConfigFiles(projectFiles[index], pattern, include, exclude);
+        const matchingConfigFiles = findMatchingConfigFiles(allProjectFiles[index], pattern, include, exclude);
         inProgressPlugins.add(pluginName);
         let r = createNodes(matchingConfigFiles, {
             nxJsonConfiguration: nxJson,
@@ -70,16 +88,23 @@ plugins) {
     }
     return Promise.all(results).then((results) => {
         spinner?.cleanup();
-        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, root, errors);
+        // Split results into specified and default plugin sets
+        const specifiedResults = results.slice(0, specifiedCount);
+        const defaultResults = results.slice(specifiedCount);
+        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(specifiedResults, defaultResults, nxJson, root, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
+        const allProjectFilesFlat = [
+            ...projectFiles.specifiedPluginFiles.flat(),
+            ...projectFiles.defaultPluginFiles.flat(),
+        ];
         if (errors.length === 0) {
             return {
                 projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles.flat(),
+                matchingProjectFiles: allProjectFilesFlat,
             };
         }
         else {
@@ -88,70 +113,133 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles.flat(),
+                matchingProjectFiles: allProjectFilesFlat,
             });
         }
     });
 }
-function mergeCreateNodesResults(results, nxJsonConfiguration, workspaceRoot, errors) {
+/**
+ * Runs a single plugin batch through two passes:
+ *
+ * 1. Every project node in every plugin result is handed to `mergeFn`,
+ *    which decides where it lands (the manager's rootMap, an
+ *    intermediate rootMap, etc.). Any failure is collected into
+ *    `errors`; processing keeps going. External nodes are accumulated
+ *    onto the shared `externalNodes` record.
+ * 2. After every project in the batch has been merged, name-reference
+ *    sentinels for the batch are registered against `nameRefRootMap` —
+ *    the rootMap the batch was merged into — so sentinels point at the
+ *    target objects that actually received the merges.
+ *
+ * The two passes can't be collapsed: a sentinel registered too early
+ * would point at the pre-merge object, and a later project in the same
+ * batch may still rename a project the sentinel refers to. Splitting
+ * the registration into a second pass also lets forward references
+ * inside the same batch resolve eagerly.
+ */
+function mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeFn, nodesManager, nameRefRootMap, externalNodes, errors) {
+    for (const result of pluginResults) {
+        const [pluginName, file, nodes, pluginIndex] = result;
+        const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
+        const sourceInfo = [file, pluginName];
+        for (const root in projectNodes) {
+            if (!projectNodes[root])
+                continue;
+            const project = { root, ...projectNodes[root] };
+            try {
+                mergeFn(project, sourceInfo);
+            }
+            catch (error) {
+                errors.push(new error_types_1.MergeNodesError({ file, pluginName, error, pluginIndex }));
+            }
+        }
+        Object.assign(externalNodes, pluginExternalNodes);
+    }
+    for (const result of pluginResults) {
+        const [pluginName, file, nodes, pluginIndex] = result;
+        const { projects: projectNodes } = nodes;
+        try {
+            nodesManager.registerNameRefs(projectNodes, nameRefRootMap);
+        }
+        catch (error) {
+            errors.push(new error_types_1.MergeNodesError({ file, pluginName, error, pluginIndex }));
+        }
+    }
+}
+/**
+ * Merges create nodes results into a single rootMap.
+ *
+ * Default plugin results are merged twice: first into an intermediate
+ * rootMap with unresolved spread sentinels preserved, so target
+ * defaults selection sees the real merged shape of defaults; then
+ * applied as a single layer onto the main rootMap where the preserved
+ * spreads resolve against the specified + target-defaults base.
+ */
+function mergeCreateNodesResults(specifiedResults, defaultResults, nxJsonConfiguration, workspaceRoot, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
     const nodesManager = new project_nodes_manager_1.ProjectNodesManager();
     const externalNodes = {};
     const configurationSourceMaps = {};
-    // Process each plugin's results in two phases:
-    //   Phase 1: Merge all projects from this plugin into rootMap/nameMap
-    //   Phase 2: Register substitutors for this plugin's results
-    //
-    // Per-plugin batching ensures that:
-    //  - All same-plugin projects are in the nameMap before substitutor
-    //    registration (fixes cross-file references like kafka-stream)
-    //  - Later-plugin renames haven't occurred yet, so dependsOn strings
-    //    that reference old names can still be resolved via the nameMap
-    for (const pluginResults of results) {
-        // Phase 1: Merge all projects from this plugin batch
-        for (const result of pluginResults) {
-            const [pluginName, file, nodes, pluginIndex] = result;
-            const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
-            const sourceInfo = [file, pluginName];
-            for (const root in projectNodes) {
-                // Handles `{projects: {'libs/foo': undefined}}`.
-                if (!projectNodes[root]) {
-                    continue;
-                }
-                const project = {
-                    root: root,
-                    ...projectNodes[root],
-                };
-                try {
-                    nodesManager.mergeProjectNode(project, configurationSourceMaps, sourceInfo);
-                }
-                catch (error) {
-                    errors.push(new error_types_1.MergeNodesError({
-                        file,
-                        pluginName,
-                        error,
-                        pluginIndex,
-                    }));
-                }
-            }
-            Object.assign(externalNodes, pluginExternalNodes);
+    const intermediateDefaultRootMap = {};
+    // Kept separate so the intermediate merge doesn't clobber
+    // specified/TD attribution on fields the defaults don't touch.
+    const defaultConfigurationSourceMaps = {};
+    const mergeToManager = (project, sourceInfo) => nodesManager.mergeProjectNode(project, configurationSourceMaps, sourceInfo);
+    const mergeToIntermediate = (project, sourceInfo) => {
+        (0, project_nodes_manager_1.mergeProjectConfigurationIntoRootMap)(intermediateDefaultRootMap, project, defaultConfigurationSourceMaps, sourceInfo, false, true);
+    };
+    for (const pluginResults of specifiedResults) {
+        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToManager, nodesManager, nodesManager.getRootMap(), externalNodes, errors);
+    }
+    for (const pluginResults of defaultResults) {
+        mergeCreateNodesResultsFromSinglePlugin(pluginResults, mergeToIntermediate, nodesManager, intermediateDefaultRootMap, externalNodes, errors);
+    }
+    const targetDefaultsResults = (0, target_defaults_1.createTargetDefaultsResults)(nodesManager.getRootMap(), intermediateDefaultRootMap, nxJsonConfiguration);
+    if (targetDefaultsResults.length > 0) {
+        mergeCreateNodesResultsFromSinglePlugin(targetDefaultsResults, mergeToManager, nodesManager, nodesManager.getRootMap(), externalNodes, errors);
+    }
+    // Apply the intermediate default rootMap as a single layer. Preserved
+    // spread sentinels resolve here against the real specified + TD base.
+    // Source maps are intentionally not written — TD attribution for
+    // fields that yield to the base (e.g. keys before `...`) stays intact.
+    for (const root in intermediateDefaultRootMap) {
+        const project = intermediateDefaultRootMap[root];
+        try {
+            nodesManager.mergeProjectNode(project, undefined, undefined);
         }
-        // Phase 2: Register substitutors for this plugin batch. The nameMap
-        // now contains all projects from this plugin (and all prior plugins)
-        // so splitTargetFromConfigurations can resolve colon-delimited strings.
-        for (const result of pluginResults) {
-            const [pluginName, file, nodes, pluginIndex] = result;
-            const { projects: projectNodes } = nodes;
-            try {
-                nodesManager.registerSubstitutors(projectNodes);
-            }
-            catch (error) {
-                errors.push(new error_types_1.MergeNodesError({
-                    file,
-                    pluginName,
-                    error,
-                    pluginIndex,
-                }));
+        catch (error) {
+            errors.push(new error_types_1.MergeNodesError({
+                file: 'nx.json',
+                pluginName: 'nx/default-plugins',
+                error,
+                pluginIndex: undefined,
+            }));
+        }
+    }
+    // The intermediate apply may have rebuilt dependsOn / inputs arrays
+    // via spread merges, leaving sentinels inserted against the
+    // intermediate rootMap pointing at now-orphaned arrays. Re-walking
+    // the final merged targets rebinds each encountered sentinel's
+    // `parent` to the current array (see
+    // ProjectNameInNodePropsManager#processInputs / processDependsOn).
+    nodesManager.registerNameRefs(intermediateDefaultRootMap);
+    // Overlay default-plugin attribution onto the main source maps using
+    // "only fill missing" semantics. Any key already present in
+    // configurationSourceMaps was written by a specified plugin or by
+    // target defaults, and that attribution is strictly more correct:
+    //  - For fields the default plugin never shadowed, the existing entry
+    //    already matches what the default plugin would overlay.
+    //  - For fields where a default plugin placed `...` after other keys,
+    //    those keys yielded to the base during the single-layer apply
+    //    above. The stale default-plugin entry in
+    //    `defaultConfigurationSourceMaps` must NOT clobber the base
+    //    attribution that the specified plugin / TD already recorded.
+    for (const root in defaultConfigurationSourceMaps) {
+        const existing = (configurationSourceMaps[root] ??= {});
+        const incoming = defaultConfigurationSourceMaps[root];
+        for (const key in incoming) {
+            if (existing[key] === undefined) {
+                existing[key] = incoming[key];
             }
         }
     }

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

@@ -2,14 +2,14 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ConfigurationResult } from './project-configuration-utils';
 import type { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
+import { SeparatedPlugins } from '../plugins/get-plugins';
 /**
- * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
+ * Walks the workspace directory to create the `projectFileMap` and `ProjectConfigurations`
  * @throws
  * @param workspaceRoot
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: Record<string, import("../../native").FileData[]>;
         nonProjectFiles: import("../../native").FileData[];
@@ -18,8 +18,11 @@ export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRoo
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
+ *
+ * Accepts separated plugin sets so that target defaults can be applied
+ * between specified and default plugin processing phases.
  */
-export declare function retrieveProjectConfigurations(plugins: LoadedNxPlugin[], workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurations(separatedPlugins: SeparatedPlugins, workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
 export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
 export declare function retrieveProjectConfigurationPaths(root: string, plugins: Array<LoadedNxPlugin>): Promise<string[]>;
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;

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

@@ -11,11 +11,10 @@ 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 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`
+ * Walks the workspace directory to create the `projectFileMap` and `ProjectConfigurations`
  * @throws
  * @param workspaceRoot
  * @param nxJson
@@ -29,7 +28,6 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
     perf_hooks_1.performance.mark('get-workspace-files:end');
     perf_hooks_1.performance.measure('get-workspace-files', 'get-workspace-files:start', 'get-workspace-files:end');
     return {
-        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(projectFileMap, globalFiles),
         fileMap: {
             projectFileMap,
             nonProjectFiles: globalFiles,
@@ -39,12 +37,26 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
 }
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
+ *
+ * Accepts separated plugin sets so that target defaults can be applied
+ * between specified and default plugin processing phases.
  */
-async function retrieveProjectConfigurations(plugins, workspaceRoot, nxJson) {
-    const pluginsWithCreateNodes = plugins.filter((p) => !!p.createNodes);
-    const globPatterns = getGlobPatternsOfPlugins(pluginsWithCreateNodes);
-    const pluginConfigFiles = await (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspaceRoot, globPatterns);
-    return (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(workspaceRoot, nxJson, pluginConfigFiles, pluginsWithCreateNodes);
+async function retrieveProjectConfigurations(separatedPlugins, workspaceRoot, nxJson) {
+    const specifiedWithCreateNodes = separatedPlugins.specifiedPlugins.filter((p) => !!p.createNodes);
+    const defaultWithCreateNodes = separatedPlugins.defaultPlugins.filter((p) => !!p.createNodes);
+    const specifiedGlobPatterns = getGlobPatternsOfPlugins(specifiedWithCreateNodes);
+    const defaultGlobPatterns = getGlobPatternsOfPlugins(defaultWithCreateNodes);
+    const [specifiedPluginFiles, defaultPluginFiles] = await Promise.all([
+        (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspaceRoot, specifiedGlobPatterns),
+        (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspaceRoot, defaultGlobPatterns),
+    ]);
+    return (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(workspaceRoot, nxJson, {
+        specifiedPluginFiles: specifiedPluginFiles ?? [],
+        defaultPluginFiles: defaultPluginFiles ?? [],
+    }, {
+        specifiedPlugins: specifiedWithCreateNodes,
+        defaultPlugins: defaultWithCreateNodes,
+    });
 }
 async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
     const pluginsToLoad = nxJson?.plugins ?? [];
@@ -53,8 +65,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 = await (0, get_plugins_1.getPlugins)(workspaceRoot);
-    const res = await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
+    const separatedPlugins = await (0, get_plugins_1.getPluginsSeparated)(workspaceRoot);
+    const res = await retrieveProjectConfigurations(separatedPlugins, workspaceRoot, nxJson);
     return res;
 }
 async function retrieveProjectConfigurationPaths(root, plugins) {
@@ -66,14 +78,21 @@ 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 = await (0, get_plugins_1.getOnlyDefaultPlugins)(); // only load default plugins
-    const projectGlobPatterns = getGlobPatternsOfPlugins(plugins);
+    const defaultPlugins = await (0, get_plugins_1.getOnlyDefaultPlugins)(); // only load default plugins
+    const pluginsWithCreateNodes = defaultPlugins.filter((p) => !!p.createNodes);
+    const projectGlobPatterns = getGlobPatternsOfPlugins(pluginsWithCreateNodes);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
     const projectFiles = (await (0, workspace_context_1.multiGlobWithWorkspaceContext)(root, projectGlobPatterns)) ?? [];
-    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(root, nxJson, projectFiles, plugins);
+    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(root, nxJson, {
+        specifiedPluginFiles: [],
+        defaultPluginFiles: projectFiles,
+    }, {
+        specifiedPlugins: [],
+        defaultPlugins: pluginsWithCreateNodes,
+    });
     projectsWithoutPluginCache.set(cacheKey, projects);
     return projects;
 }

package/package.json

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