nx 18.3.0-beta.0 → 18.3.0-beta.1

package/src/{utils/nx-plugin.d.ts → project-graph/plugins/public-api.d.ts}

@@ -1,9 +1,8 @@
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
-import { PackageJson } from './package-json';
-import { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { NxJsonConfiguration, PluginConfiguration } from '../config/nx-json';
-import { NxPluginV1 } from './nx-plugin.deprecated';
-import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { RawProjectGraphDependency } from '../project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
@@ -20,6 +19,7 @@ export interface CreateNodesContext {
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
      * A map of project root -> project configuration
@@ -34,7 +34,7 @@ export interface CreateNodesResult {
  * A pair of file patterns and {@link CreateNodesFunction}
  */
 export type CreateNodes<T = unknown> = readonly [
-    configFilePattern: string,
+    projectFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
 /**
@@ -77,49 +77,13 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
      */
-    createNodes?: CreateNodes;
+    createNodes?: CreateNodes<TOptions>;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
     createDependencies?: CreateDependencies<TOptions>;
 };
-export * from './nx-plugin.deprecated';
 /**
  * A plugin for Nx
  */
 export type NxPlugin = NxPluginV1 | NxPluginV2;
-export type LoadedNxPlugin = {
-    plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
-    options?: unknown;
-    include?: string[];
-    exclude?: string[];
-};
-export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
-export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
-    pluginPath: string;
-    name: any;
-};
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
-export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string, projects?: Record<string, ProjectConfiguration>): Promise<LoadedNxPlugin[]>;
-export declare function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2;
-export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
-export declare function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1;
-export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
-    path: string;
-    json: PackageJson;
-};
-export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
-    path: string;
-    projectConfig: ProjectConfiguration;
-} | null;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-export declare function registerPluginTSTranspiler(): void;
-/**
- * Unregister the ts-node transpiler if it is registered
- */
-export declare function unregisterPluginTSTranspiler(): void;
-export declare function getDefaultPlugins(root: string): Promise<LoadedNxPlugin[]>;
-type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/project-graph/plugins/public-api.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file represents the public API for plugins which live in nx.json's plugins array.
+// For methods to interact with plugins from within Nx, see `./internal-api.ts`.
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,7 @@
+import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
+import type { CreateNodesContext, NxPlugin, NxPluginV2 } from './public-api';
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
+export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
+export declare function runCreateNodesInParallel(configFiles: string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCreateNodesInParallel = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
+const node_path_1 = require("node:path");
+const workspaces_1 = require("../../config/workspaces");
+const globs_1 = require("../../utils/globs");
+const error_types_1 = require("../error-types");
+function isNxPluginV2(plugin) {
+    return 'createNodes' in plugin || 'createDependencies' in plugin;
+}
+exports.isNxPluginV2 = isNxPluginV2;
+function isNxPluginV1(plugin) {
+    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
+}
+exports.isNxPluginV1 = isNxPluginV1;
+function normalizeNxPlugin(plugin) {
+    if (isNxPluginV2(plugin)) {
+        return plugin;
+    }
+    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
+        return {
+            ...plugin,
+            createNodes: [
+                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
+                (configFilePath) => {
+                    const root = (0, node_path_1.dirname)(configFilePath);
+                    return {
+                        projects: {
+                            [root]: {
+                                name: (0, workspaces_1.toProjectName)(configFilePath),
+                                targets: plugin.registerProjectTargets?.(configFilePath),
+                            },
+                        },
+                    };
+                },
+            ],
+        };
+    }
+    return plugin;
+}
+exports.normalizeNxPlugin = normalizeNxPlugin;
+async function runCreateNodesInParallel(configFiles, plugin, options, context) {
+    performance.mark(`${plugin.name}:createNodes - start`);
+    const promises = configFiles.map((file) => {
+        performance.mark(`${plugin.name}:createNodes:${file} - start`);
+        // Result is either static or a promise, using Promise.resolve lets us
+        // handle both cases with same logic
+        const value = Promise.resolve(plugin.createNodes[1](file, options, context));
+        return value
+            .catch((e) => {
+            performance.mark(`${plugin.name}:createNodes:${file} - end`);
+            return new error_types_1.CreateNodesError({
+                error: e,
+                pluginName: plugin.name,
+                file,
+            });
+        })
+            .then((r) => {
+            performance.mark(`${plugin.name}:createNodes:${file} - end`);
+            performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+            return { ...r, pluginName: plugin.name, file };
+        });
+    });
+    const results = await Promise.all(promises).then((results) => {
+        performance.mark(`${plugin.name}:createNodes - end`);
+        performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+        return results;
+    });
+    const [errors, successful] = partition(results, (r) => r instanceof error_types_1.CreateNodesError);
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateCreateNodesError(plugin.name, errors, successful);
+    }
+    return results;
+}
+exports.runCreateNodesInParallel = runCreateNodesInParallel;
+function partition(arr, test) {
+    const pass = [];
+    const fail = [];
+    for (const item of arr) {
+        if (test(item)) {
+            pass.push(item);
+        }
+        else {
+            fail.push(item);
+        }
+    }
+    return [pass, fail];
+}

package/src/project-graph/project-graph-builder.d.ts

@@ -2,7 +2,7 @@
  * Builder for adding nodes and dependencies to a {@link ProjectGraph}
  */
 import { DependencyType, FileMap, ProjectFileMap, ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../config/project-graph';
-import { CreateDependenciesContext } from '../utils/nx-plugin';
+import { CreateDependenciesContext } from './plugins';
 /**
  * A class which builds up a project graph
  * @deprecated The {@link ProjectGraphProcessor} has been deprecated. Use a {@link CreateNodes} and/or a {@link CreateDependencies} instead. This will be removed in Nx 19.

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

@@ -1,7 +1,8 @@
 import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
-import { ConfigurationSourceMaps, CreateNodesError, MergeNodesError } from './utils/project-configuration-utils';
+import { ConfigurationSourceMaps } from './utils/project-configuration-utils';
+import { CreateNodesError, MergeNodesError } from './error-types';
 import { DaemonProjectGraphError } from '../daemon/daemon-project-graph-error';
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
@@ -33,7 +34,7 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (ProcessDependenciesError | ProcessProjectGraphError | CreateNodesError)[];
+    getErrors(): (CreateNodesError | ProcessDependenciesError | ProcessProjectGraphError)[];
 }
 /**
  * Computes and returns a ProjectGraph.

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

@@ -14,8 +14,8 @@ const workspace_root_1 = require("../utils/workspace-root");
 const perf_hooks_1 = require("perf_hooks");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const nx_json_1 = require("../config/nx-json");
-const nx_plugin_1 = require("../utils/nx-plugin");
-const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const error_types_1 = require("./error-types");
+const internal_api_1 = require("./plugins/internal-api");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -69,17 +69,17 @@ function readProjectsConfigurationFromProjectGraph(projectGraph) {
 }
 exports.readProjectsConfigurationFromProjectGraph = readProjectsConfigurationFromProjectGraph;
 async function buildProjectGraphAndSourceMapsWithoutDaemon() {
-    // Set this globally to allow plugins to know if they are being called from the project graph creation
     global.NX_GRAPH_CREATION = true;
     const nxJson = (0, nx_json_1.readNxJson)();
     perf_hooks_1.performance.mark('retrieve-project-configurations:start');
     let configurationResult;
     let projectConfigurationsError;
+    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson.plugins);
     try {
-        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
     }
     catch (e) {
-        if (e instanceof project_configuration_utils_1.ProjectConfigurationsError) {
+        if (e instanceof error_types_1.ProjectConfigurationsError) {
             projectConfigurationsError = e;
             configurationResult = e.partialProjectConfigurationsResult;
         }
@@ -97,7 +97,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     let createDependenciesError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins);
     }
     catch (e) {
         if (e instanceof build_project_graph_1.CreateDependenciesError) {
@@ -111,9 +111,11 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
             throw e;
         }
     }
+    finally {
+        cleanup();
+    }
     const { projectGraph, projectFileMapCache } = projectGraphResult;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
-    (0, nx_plugin_1.unregisterPluginTSTranspiler)();
     delete global.NX_GRAPH_CREATION;
     const errors = [
         ...(projectConfigurationsError?.errors ?? []),

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -1,7 +1,7 @@
 import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
-import { CreateDependenciesContext } from '../../utils/nx-plugin';
+import { CreateDependenciesContext } from '../plugins';
 export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
 /**
  * Apply target defaults and normalization

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

@@ -1,8 +1,8 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
-import { LoadedNxPlugin } from '../../utils/nx-plugin';
-import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/target-defaults-plugin';
+import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/symbols';
+import { LoadedNxPlugin } from '../plugins/internal-api';
 export type SourceInformation = [file: string, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
 export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
@@ -24,32 +24,9 @@ export type ConfigurationResult = {
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
  */
-export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, workspaceFiles: string[], // making this parameter allows devkit to pick up newly created projects
+export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
 plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
-export declare class ProjectConfigurationsError extends Error {
-    readonly errors: Array<MergeNodesError | CreateNodesError>;
-    readonly partialProjectConfigurationsResult: ConfigurationResult;
-    constructor(errors: Array<MergeNodesError | CreateNodesError>, partialProjectConfigurationsResult: ConfigurationResult);
-}
-export declare class CreateNodesError extends Error {
-    file: string;
-    pluginName: string;
-    constructor({ file, pluginName, error, }: {
-        file: string;
-        pluginName: string;
-        error: Error;
-    });
-}
-export declare class MergeNodesError extends Error {
-    file: string;
-    pluginName: string;
-    constructor({ file, pluginName, error, }: {
-        file: string;
-        pluginName: string;
-        error: Error;
-    });
-}
 /**
  * Merges two targets.
  *

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

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.MergeNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const logger_1 = require("../../utils/logger");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
-const target_defaults_plugin_1 = require("../../plugins/target-defaults/target-defaults-plugin");
+const symbols_1 = require("../../plugins/target-defaults/symbols");
 const minimatch_1 = require("minimatch");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
+const error_types_1 = require("../error-types");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -119,12 +120,12 @@ skipCommandNormalization) {
             // Always set source map info for the target, but don't overwrite info already there
             // if augmenting an existing target.
             const target = project.targets?.[targetName];
-            if (sourceMap && !target?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET]) {
+            if (sourceMap && !target?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET]) {
                 sourceMap[`targets.${targetName}`] = sourceInformation;
             }
             // If ONLY_MODIFIES_EXISTING_TARGET is true, and its not on the matching project
             // we shouldn't merge its info into the graph
-            if (target?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET] &&
+            if (target?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET] &&
                 !matchingProject.targets?.[targetName]) {
                 continue;
             }
@@ -132,8 +133,8 @@ skipCommandNormalization) {
                 ? target
                 : resolveCommandSyntacticSugar(target, project.root), matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
             // We don't want the symbol to live on past the merge process
-            if (mergedTarget?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET])
-                delete mergedTarget?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET];
+            if (mergedTarget?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET])
+                delete mergedTarget?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET];
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
@@ -217,21 +218,19 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
  */
-function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, workspaceFiles, // making this parameter allows devkit to pick up newly created projects
+async function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
 plugins) {
     perf_hooks_1.performance.mark('build-project-configs:start');
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const { plugin, options, include, exclude } of plugins) {
-        const [pattern, createNodes] = plugin.createNodes ?? [];
-        const pluginResults = [];
-        perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
+    for (const { name: pluginName, createNodes: createNodesTuple, include, exclude, } of plugins) {
+        const [pattern, createNodes] = createNodesTuple ?? [];
         if (!pattern) {
             continue;
         }
         const matchingConfigFiles = [];
-        for (const file of workspaceFiles) {
+        for (const file of projectFiles) {
             if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
                 if (include) {
                     const included = include.some((includedPattern) => (0, minimatch_1.minimatch)(file, includedPattern, { dot: true }));
@@ -240,7 +239,7 @@ plugins) {
                     }
                 }
                 if (exclude) {
-                    const excluded = include.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
+                    const excluded = exclude.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
                     if (excluded) {
                         continue;
                     }
@@ -248,56 +247,20 @@ plugins) {
                 matchingConfigFiles.push(file);
             }
         }
-        for (const file of matchingConfigFiles) {
-            perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - start`);
-            try {
-                let r = createNodes(file, options, {
-                    nxJsonConfiguration: nxJson,
-                    workspaceRoot: root,
-                    configFiles: matchingConfigFiles,
-                });
-                if (r instanceof Promise) {
-                    pluginResults.push(r
-                        .catch((error) => {
-                        perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        errors.push(new CreateNodesError({
-                            file,
-                            pluginName: plugin.name,
-                            error,
-                        }));
-                        return {
-                            projects: {},
-                        };
-                    })
-                        .then((r) => {
-                        perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        perf_hooks_1.performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-                        return { ...r, file, pluginName: plugin.name };
-                    }));
-                }
-                else {
-                    perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                    perf_hooks_1.performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-                    pluginResults.push({
-                        ...r,
-                        file,
-                        pluginName: plugin.name,
-                    });
-                }
+        let r = createNodes(matchingConfigFiles, {
+            nxJsonConfiguration: nxJson,
+            workspaceRoot: root,
+            configFiles: matchingConfigFiles,
+        }).catch((e) => {
+            if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                errors.push(...e.errors);
+                return e.partialResults;
             }
-            catch (error) {
-                errors.push(new CreateNodesError({
-                    file,
-                    pluginName: plugin.name,
-                    error,
-                }));
+            else {
+                throw e;
             }
-        }
-        results.push(Promise.all(pluginResults).then((results) => {
-            perf_hooks_1.performance.mark(`${plugin.name}:createNodes - end`);
-            perf_hooks_1.performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
-            return results;
-        }));
+        });
+        results.push(r);
     }
     return Promise.all(results).then((results) => {
         perf_hooks_1.performance.mark('createNodes:merge - start');
@@ -307,8 +270,8 @@ plugins) {
         for (const result of results.flat()) {
             const { projects: projectNodes, externalNodes: pluginExternalNodes, file, pluginName, } = result;
             const sourceInfo = [file, pluginName];
-            if (result[target_defaults_plugin_1.OVERRIDE_SOURCE_FILE]) {
-                sourceInfo[0] = result[target_defaults_plugin_1.OVERRIDE_SOURCE_FILE];
+            if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
+                sourceInfo[0] = result[symbols_1.OVERRIDE_SOURCE_FILE];
             }
             for (const node in projectNodes) {
                 const project = {
@@ -319,7 +282,7 @@ plugins) {
                     mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
                 }
                 catch (error) {
-                    errors.push(new MergeNodesError({
+                    errors.push(new error_types_1.MergeNodesError({
                         file,
                         pluginName,
                         error,
@@ -343,7 +306,7 @@ plugins) {
             };
         }
         else {
-            throw new ProjectConfigurationsError(errors, {
+            throw new error_types_1.ProjectConfigurationsError(errors, {
                 projects,
                 externalNodes,
                 projectRootMap: rootMap,
@@ -395,37 +358,6 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
-class ProjectConfigurationsError extends Error {
-    constructor(errors, partialProjectConfigurationsResult) {
-        super('Failed to create project configurations');
-        this.errors = errors;
-        this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
-        this.name = this.constructor.name;
-    }
-}
-exports.ProjectConfigurationsError = ProjectConfigurationsError;
-class CreateNodesError extends Error {
-    constructor({ file, pluginName, error, }) {
-        const msg = `The "${pluginName}" plugin threw an error while creating nodes from ${file}:`;
-        super(msg, { cause: error });
-        this.name = this.constructor.name;
-        this.file = file;
-        this.pluginName = pluginName;
-        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
-    }
-}
-exports.CreateNodesError = CreateNodesError;
-class MergeNodesError extends Error {
-    constructor({ file, pluginName, error, }) {
-        const msg = `The nodes created from ${file} by the "${pluginName}" could not be merged into the project graph:`;
-        super(msg, { cause: error });
-        this.name = this.constructor.name;
-        this.file = file;
-        this.pluginName = pluginName;
-        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
-    }
-}
-exports.MergeNodesError = MergeNodesError;
 /**
  * Merges two targets.
  *
@@ -448,7 +380,7 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     // with the new one. However, we have a special case for targets that have the
     // ONLY_MODIFIES_EXISTING_TARGET symbol set. This prevents the merged target
     // equaling info that should have only been used to modify the existing target.
-    if (!isCompatible && target[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET]) {
+    if (!isCompatible && target[symbols_1.ONLY_MODIFIES_EXISTING_TARGET]) {
         return baseTarget;
     }
     if (!isCompatible && projectConfigSourceMap) {

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

@@ -1,7 +1,7 @@
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ConfigurationResult } from './project-configuration-utils';
-import { LoadedNxPlugin } from '../../utils/nx-plugin';
+import { LoadedNxPlugin } from '../plugins/internal-api';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -9,21 +9,22 @@ import { LoadedNxPlugin } from '../../utils/nx-plugin';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
- *
- * @param workspaceRoot
- * @param nxJson
  */
-export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+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: LoadedNxPlugin[]): string[];
+export declare function retrieveProjectConfigurationPaths(root: string, plugins: Array<{
+    createNodes?: readonly [string, ...unknown[]];
+} & unknown>): string[];
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function configurationGlobs(plugins: LoadedNxPlugin[]): string[];
+export declare function configurationGlobs(plugins: Array<{
+    createNodes?: readonly [string, ...unknown[]];
+}>): string[];