nx 22.6.0 → 22.6.2

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

@@ -0,0 +1,332 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = deepClone;
+exports.resolveCommandSyntacticSugar = resolveCommandSyntacticSugar;
+exports.mergeMetadata = mergeMetadata;
+exports.mergeTargetConfigurations = mergeTargetConfigurations;
+exports.isCompatibleTarget = isCompatibleTarget;
+exports.mergeTargetDefaultWithTargetDefinition = mergeTargetDefaultWithTargetDefinition;
+exports.resolveNxTokensInOptions = resolveNxTokensInOptions;
+exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
+const logger_1 = require("../../../utils/logger");
+const globs_1 = require("../../../utils/globs");
+const source_maps_1 = require("./source-maps");
+const minimatch_1 = require("minimatch");
+function deepClone(obj) {
+    return structuredClone(obj);
+}
+function resolveCommandSyntacticSugar(target, key) {
+    const { command, ...config } = target ?? {};
+    if (!command) {
+        return target;
+    }
+    if (config.executor) {
+        throw new Error(`${logger_1.NX_PREFIX} Project at ${key} should not have executor and command both configured.`);
+    }
+    else {
+        return {
+            ...config,
+            executor: 'nx:run-commands',
+            options: {
+                ...config.options,
+                command: command,
+            },
+        };
+    }
+}
+function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata, matchingMetadata) {
+    const result = {
+        ...(matchingMetadata ?? {}),
+    };
+    for (const [metadataKey, value] of Object.entries(metadata)) {
+        const existingValue = matchingMetadata?.[metadataKey];
+        if (Array.isArray(value) && Array.isArray(existingValue)) {
+            const startIndex = result[metadataKey].length;
+            result[metadataKey].push(...value);
+            if (sourceMap) {
+                (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}`, result[metadataKey], sourceInformation, startIndex);
+            }
+        }
+        else if (Array.isArray(value) && existingValue === undefined) {
+            result[metadataKey] ??= value;
+            if (sourceMap) {
+                sourceMap[`${baseSourceMapPath}.${metadataKey}`] = sourceInformation;
+                (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}`, value, sourceInformation);
+            }
+        }
+        else if (typeof value === 'object' && typeof existingValue === 'object') {
+            for (const key in value) {
+                const existingValue = matchingMetadata?.[metadataKey]?.[key];
+                if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
+                    const startIndex = result[metadataKey][key].length;
+                    result[metadataKey][key].push(...value[key]);
+                    if (sourceMap) {
+                        (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}.${key}`, result[metadataKey][key], sourceInformation, startIndex);
+                    }
+                }
+                else {
+                    result[metadataKey][key] = value[key];
+                    if (sourceMap) {
+                        sourceMap[`${baseSourceMapPath}.${metadataKey}`] =
+                            sourceInformation;
+                    }
+                }
+            }
+        }
+        else {
+            result[metadataKey] = value;
+            if (sourceMap) {
+                sourceMap[`${baseSourceMapPath}.${metadataKey}`] = sourceInformation;
+                if (typeof value === 'object') {
+                    for (const k in value) {
+                        sourceMap[`${baseSourceMapPath}.${metadataKey}.${k}`] =
+                            sourceInformation;
+                        if (Array.isArray(value[k])) {
+                            (0, source_maps_1.recordSourceMapKeysByIndex)(sourceMap, `${baseSourceMapPath}.${metadataKey}.${k}`, value[k], sourceInformation);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+function mergeOptions(newOptions, baseOptions, projectConfigSourceMap, sourceInformation, targetIdentifier) {
+    const mergedOptions = {
+        ...(baseOptions ?? {}),
+        ...(newOptions ?? {}),
+    };
+    // record new options & option properties in source map
+    if (projectConfigSourceMap) {
+        for (const newOption in newOptions) {
+            projectConfigSourceMap[`${targetIdentifier}.options.${newOption}`] =
+                sourceInformation;
+        }
+    }
+    return mergedOptions;
+}
+function mergeConfigurations(newConfigurations, baseConfigurations, projectConfigSourceMap, sourceInformation, targetIdentifier) {
+    const mergedConfigurations = {};
+    const configurations = new Set([
+        ...Object.keys(baseConfigurations ?? {}),
+        ...Object.keys(newConfigurations ?? {}),
+    ]);
+    for (const configuration of configurations) {
+        mergedConfigurations[configuration] = {
+            ...(baseConfigurations?.[configuration] ?? {}),
+            ...(newConfigurations?.[configuration] ?? {}),
+        };
+    }
+    // record new configurations & configuration properties in source map
+    if (projectConfigSourceMap) {
+        for (const newConfiguration in newConfigurations) {
+            projectConfigSourceMap[`${targetIdentifier}.configurations.${newConfiguration}`] = sourceInformation;
+            for (const configurationProperty in newConfigurations[newConfiguration]) {
+                projectConfigSourceMap[`${targetIdentifier}.configurations.${newConfiguration}.${configurationProperty}`] = sourceInformation;
+            }
+        }
+    }
+    return mergedConfigurations;
+}
+/**
+ * Merges two targets.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The target definition with higher priority
+ * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
+ * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
+ * @param sourceInformation The metadata about where the new target was defined
+ * @param targetIdentifier The identifier for the target to merge, used for source map
+ * @returns A merged target configuration
+ */
+function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, sourceInformation, targetIdentifier) {
+    const { configurations: defaultConfigurations, options: defaultOptions, ...baseTargetProperties } = baseTarget ?? {};
+    // Target is "compatible", e.g. executor is defined only once or is the same
+    // in both places. This means that it is likely safe to merge
+    const isCompatible = isCompatibleTarget(baseTarget ?? {}, target);
+    if (!isCompatible && projectConfigSourceMap) {
+        // if the target is not compatible, we will simply override the options
+        // we have to delete old entries from the source map
+        for (const key in projectConfigSourceMap) {
+            if (key.startsWith(`${targetIdentifier}`)) {
+                delete projectConfigSourceMap[key];
+            }
+        }
+    }
+    // merge top level properties if they're compatible
+    const result = {
+        ...(isCompatible ? baseTargetProperties : {}),
+        ...target,
+    };
+    // record top level properties in source map
+    if (projectConfigSourceMap) {
+        projectConfigSourceMap[targetIdentifier] = sourceInformation;
+        // record root level target properties to source map
+        for (const targetProperty in target) {
+            const targetPropertyId = `${targetIdentifier}.${targetProperty}`;
+            projectConfigSourceMap[targetPropertyId] = sourceInformation;
+        }
+    }
+    // merge options if there are any
+    // if the targets aren't compatible, we simply discard the old options during the merge
+    if (target.options || defaultOptions) {
+        result.options = mergeOptions(target.options, isCompatible ? defaultOptions : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier);
+    }
+    // merge configurations if there are any
+    // if the targets aren't compatible, we simply discard the old configurations during the merge
+    if (target.configurations || defaultConfigurations) {
+        result.configurations = mergeConfigurations(target.configurations, isCompatible ? defaultConfigurations : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier);
+    }
+    if (target.metadata) {
+        result.metadata = mergeMetadata(projectConfigSourceMap, sourceInformation, `${targetIdentifier}.metadata`, target.metadata, baseTarget?.metadata);
+    }
+    return result;
+}
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+function isCompatibleTarget(a, b) {
+    const oneHasNoExecutor = !a.executor || !b.executor;
+    const bothHaveSameExecutor = a.executor === b.executor;
+    if (oneHasNoExecutor)
+        return true;
+    if (!bothHaveSameExecutor)
+        return false;
+    const isRunCommands = a.executor === 'nx:run-commands';
+    if (isRunCommands) {
+        const aCommand = a.options?.command ?? a.options?.commands?.join(' && ');
+        const bCommand = b.options?.command ?? b.options?.commands?.join(' && ');
+        const oneHasNoCommand = !aCommand || !bCommand;
+        const hasSameCommand = aCommand === bCommand;
+        return oneHasNoCommand || hasSameCommand;
+    }
+    const isRunScript = a.executor === 'nx:run-script';
+    if (isRunScript) {
+        const aScript = a.options?.script;
+        const bScript = b.options?.script;
+        const oneHasNoScript = !aScript || !bScript;
+        const hasSameScript = aScript === bScript;
+        return oneHasNoScript || hasSameScript;
+    }
+    return true;
+}
+function targetDefaultShouldBeApplied(key, sourceMap) {
+    const sourceInfo = sourceMap[key];
+    if (!sourceInfo) {
+        return true;
+    }
+    // The defined value of the target is from a plugin that
+    // isn't part of Nx's core plugins, so target defaults are
+    // applied on top of it.
+    const [, plugin] = sourceInfo;
+    return !plugin?.startsWith('nx/');
+}
+function mergeTargetDefaultWithTargetDefinition(targetName, project, targetDefault, sourceMap) {
+    const targetDefinition = project.targets[targetName] ?? {};
+    const result = deepClone(targetDefinition);
+    for (const key in targetDefault) {
+        switch (key) {
+            case 'options': {
+                const normalizedDefaults = resolveNxTokensInOptions(targetDefault.options, project, targetName);
+                for (const optionKey in normalizedDefaults) {
+                    const sourceMapKey = (0, source_maps_1.targetOptionSourceMapKey)(targetName, optionKey);
+                    if (targetDefinition.options[optionKey] === undefined ||
+                        targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
+                        result.options[optionKey] = targetDefault.options[optionKey];
+                        sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
+                    }
+                }
+                break;
+            }
+            case 'configurations': {
+                if (!result.configurations) {
+                    result.configurations = {};
+                    sourceMap[(0, source_maps_1.targetConfigurationsSourceMapKey)(targetName)] = [
+                        'nx.json',
+                        'nx/target-defaults',
+                    ];
+                }
+                for (const configuration in targetDefault.configurations) {
+                    if (!result.configurations[configuration]) {
+                        result.configurations[configuration] = {};
+                        sourceMap[(0, source_maps_1.targetConfigurationsSourceMapKey)(targetName, configuration)] = ['nx.json', 'nx/target-defaults'];
+                    }
+                    const normalizedConfigurationDefaults = resolveNxTokensInOptions(targetDefault.configurations[configuration], project, targetName);
+                    for (const configurationKey in normalizedConfigurationDefaults) {
+                        const sourceMapKey = (0, source_maps_1.targetConfigurationsSourceMapKey)(targetName, configuration, configurationKey);
+                        if (targetDefinition.configurations?.[configuration]?.[configurationKey] === undefined ||
+                            targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
+                            result.configurations[configuration][configurationKey] =
+                                targetDefault.configurations[configuration][configurationKey];
+                            sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
+                        }
+                    }
+                }
+                break;
+            }
+            default: {
+                const sourceMapKey = `targets.${targetName}.${key}`;
+                if (targetDefinition[key] === undefined ||
+                    targetDefaultShouldBeApplied(sourceMapKey, sourceMap)) {
+                    result[key] = targetDefault[key];
+                    sourceMap[sourceMapKey] = ['nx.json', 'nx/target-defaults'];
+                }
+                break;
+            }
+        }
+    }
+    return result;
+}
+function resolveNxTokensInOptions(object, project, key) {
+    const result = Array.isArray(object) ? [...object] : { ...object };
+    for (let [opt, value] of Object.entries(object ?? {})) {
+        if (typeof value === 'string') {
+            const workspaceRootMatch = /^(\{workspaceRoot\}\/?)/.exec(value);
+            if (workspaceRootMatch?.length) {
+                value = value.replace(workspaceRootMatch[0], '');
+            }
+            if (value.includes('{workspaceRoot}')) {
+                throw new Error(`${logger_1.NX_PREFIX} The {workspaceRoot} token is only valid at the beginning of an option. (${key})`);
+            }
+            value = value.replace(/\{projectRoot\}/g, project.root);
+            result[opt] = value.replace(/\{projectName\}/g, project.name);
+        }
+        else if (typeof value === 'object' && value) {
+            result[opt] = resolveNxTokensInOptions(value, project, [key, opt].join('.'));
+        }
+    }
+    return result;
+}
+function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
+    if (executor && targetDefaults?.[executor]) {
+        // If an executor is defined in project.json, defaults should be read
+        // from the most specific key that matches that executor.
+        // e.g. If executor === run-commands, and the target is named build:
+        // Use, use nx:run-commands if it is present
+        // If not, use build if it is present.
+        return targetDefaults?.[executor];
+    }
+    else if (targetDefaults?.[targetName]) {
+        // If the executor is not defined, the only key we have is the target name.
+        return targetDefaults?.[targetName];
+    }
+    let matchingTargetDefaultKey = null;
+    for (const key in targetDefaults ?? {}) {
+        if ((0, globs_1.isGlobPattern)(key) && (0, minimatch_1.minimatch)(targetName, key)) {
+            if (!matchingTargetDefaultKey ||
+                matchingTargetDefaultKey.length < key.length) {
+                matchingTargetDefaultKey = key;
+            }
+        }
+    }
+    if (matchingTargetDefaultKey) {
+        return targetDefaults[matchingTargetDefaultKey];
+    }
+    return null;
+}

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

@@ -0,0 +1,13 @@
+import { NxJsonConfiguration } from '../../../config/nx-json';
+import { ProjectConfiguration, TargetConfiguration } from '../../../config/workspace-json-project-json';
+import type { ConfigurationSourceMaps } from './source-maps';
+export declare function validateProject(project: ProjectConfiguration, knownProjects: Record<string, ProjectConfiguration>): void;
+/**
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
+ * @param target The target to normalize
+ * @param project The project that the target belongs to
+ * @returns The normalized target configuration
+ */
+export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration, workspaceRoot: string, projectsMap: Record<string, ProjectConfiguration>, errorMsgKey: string): TargetConfiguration<any>;
+export declare function validateAndNormalizeProjectRootMap(workspaceRoot: string, projectRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration, sourceMaps?: ConfigurationSourceMaps): Record<string, ProjectConfiguration>;
+//# sourceMappingURL=target-normalization.d.ts.map

package/src/project-graph/utils/project-configuration/target-normalization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target-normalization.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/utils/project-configuration/target-normalization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,6CAA6C,CAAC;AAyBrD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAK7D,wBAAgB,eAAe,CAC7B,OAAO,EAAE,oBAAoB,EAE7B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,QAkBpD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,oBAAoB,EAC7B,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACjD,WAAW,EAAE,MAAM,4BAiDpB;AAiFD,wBAAgB,kCAAkC,CAChD,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACpD,mBAAmB,EAAE,mBAAmB,EACxC,UAAU,GAAE,uBAA4B,wCA+EzC"}

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

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProject = validateProject;
+exports.normalizeTarget = normalizeTarget;
+exports.validateAndNormalizeProjectRootMap = validateAndNormalizeProjectRootMap;
+const executor_utils_1 = require("../../../command-line/run/executor-utils");
+const fileutils_1 = require("../../../utils/fileutils");
+const to_project_name_1 = require("../../../config/to-project-name");
+const error_types_1 = require("../../error-types");
+const target_merging_1 = require("./target-merging");
+const node_fs_1 = require("node:fs");
+const path_1 = require("path");
+function validateProject(project, 
+// name -> project
+knownProjects) {
+    if (!project.name) {
+        try {
+            const { name } = (0, fileutils_1.readJsonFile)((0, path_1.join)(project.root, 'package.json'));
+            if (!name) {
+                throw new Error(`Project at ${project.root} has no name provided.`);
+            }
+            project.name = name;
+        }
+        catch {
+            throw new error_types_1.ProjectWithNoNameError(project.root);
+        }
+    }
+    else if (knownProjects[project.name] &&
+        knownProjects[project.name].root !== project.root) {
+        throw new error_types_1.ProjectWithExistingNameError(project.name, project.root);
+    }
+}
+/**
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
+ * @param target The target to normalize
+ * @param project The project that the target belongs to
+ * @returns The normalized target configuration
+ */
+function normalizeTarget(target, project, workspaceRoot, projectsMap, errorMsgKey) {
+    target = {
+        ...target,
+        configurations: {
+            ...target.configurations,
+        },
+    };
+    target = (0, target_merging_1.resolveCommandSyntacticSugar)(target, project.root);
+    target.options = (0, target_merging_1.resolveNxTokensInOptions)(target.options, project, errorMsgKey);
+    for (const configuration in target.configurations) {
+        target.configurations[configuration] = (0, target_merging_1.resolveNxTokensInOptions)(target.configurations[configuration], project, `${project.root}:${target}:${configuration}`);
+    }
+    target.parallelism ??= true;
+    if (target.executor && !('continuous' in target)) {
+        try {
+            const [executorNodeModule, executorName] = (0, executor_utils_1.parseExecutor)(target.executor);
+            const { schema } = (0, executor_utils_1.getExecutorInformation)(executorNodeModule, executorName, workspaceRoot, projectsMap);
+            if (schema.continuous) {
+                target.continuous ??= schema.continuous;
+            }
+        }
+        catch (e) {
+            // If the executor is not found, we assume that it is not a valid executor.
+            // This means that we should not set the continuous property.
+            // We could throw an error here, but it would be better to just ignore it.
+        }
+    }
+    return target;
+}
+function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
+/**
+ * Project configurations keyed by project name
+ */
+projects) {
+    const targetErrorMessage = [];
+    for (const targetName in project.targets) {
+        project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects, [project.root, targetName].join(':'));
+        const projectSourceMaps = sourceMaps[project.root];
+        const targetConfig = project.targets[targetName];
+        const targetDefaults = (0, target_merging_1.deepClone)((0, target_merging_1.readTargetDefaultsForTarget)(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor));
+        // We only apply defaults if they exist
+        if (targetDefaults && (0, target_merging_1.isCompatibleTarget)(targetConfig, targetDefaults)) {
+            project.targets[targetName] = (0, target_merging_1.mergeTargetDefaultWithTargetDefinition)(targetName, project, normalizeTarget(targetDefaults, project, workspaceRoot, projects, ['nx.json[targetDefaults]', targetName].join(':')), projectSourceMaps);
+        }
+        const target = project.targets[targetName];
+        if (
+        // If the target has no executor or command, it doesn't do anything
+        !target.executor &&
+            !target.command) {
+            // But it may have dependencies that do something
+            if (target.dependsOn && target.dependsOn.length > 0) {
+                target.executor = 'nx:noop';
+            }
+            else {
+                // If it does nothing, and has no depenencies,
+                // we can remove it.
+                delete project.targets[targetName];
+            }
+        }
+        if (target.cache && target.continuous) {
+            targetErrorMessage.push(`- "${targetName}" has both "cache" and "continuous" set to true. Continuous targets cannot be cached. Please remove the "cache" property.`);
+        }
+    }
+    if (targetErrorMessage.length > 0) {
+        targetErrorMessage.unshift(`Errors detected in targets of project "${project.name}":`);
+        throw new error_types_1.WorkspaceValidityError(targetErrorMessage.join('\n'));
+    }
+}
+function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
+    // Name -> Project, used to validate that all projects have unique names
+    const projects = {};
+    // If there are projects that have the same name, that is an error.
+    // This object tracks name -> (all roots of projects with that name)
+    // to provide better error messaging.
+    const conflicts = new Map();
+    const projectRootsWithNoName = [];
+    const validityErrors = [];
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
+        // Strip it before returning configuration for usage.
+        if (project['// targets'])
+            delete project['// targets'];
+        // We initially did this in the project.json plugin, but
+        // that resulted in project.json files without names causing
+        // the resulting project to change names from earlier plugins...
+        if (!project.name &&
+            (0, node_fs_1.existsSync)((0, path_1.join)(workspaceRoot, project.root, 'project.json'))) {
+            project.name = (0, to_project_name_1.toProjectName)((0, path_1.join)(root, 'project.json'));
+        }
+        try {
+            validateProject(project, projects);
+            projects[project.name] = project;
+        }
+        catch (e) {
+            if ((0, error_types_1.isProjectWithNoNameError)(e)) {
+                projectRootsWithNoName.push(e.projectRoot);
+            }
+            else if ((0, error_types_1.isProjectWithExistingNameError)(e)) {
+                const rootErrors = conflicts.get(e.projectName) ?? [
+                    projects[e.projectName].root,
+                ];
+                rootErrors.push(e.projectRoot);
+                conflicts.set(e.projectName, rootErrors);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        try {
+            normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects);
+        }
+        catch (e) {
+            if (e instanceof error_types_1.WorkspaceValidityError) {
+                validityErrors.push(e);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    const errors = [];
+    if (conflicts.size > 0) {
+        errors.push(new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects));
+    }
+    if (projectRootsWithNoName.length > 0) {
+        errors.push(new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects));
+    }
+    if (validityErrors.length > 0) {
+        errors.push(...validityErrors);
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors);
+    }
+    return projectRootMap;
+}

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

@@ -1,13 +1,11 @@
-import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../config/workspace-json-project-json';
+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 type { ConfigurationSourceMaps, SourceInformation };
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): {
-    previousName?: string;
-};
-export declare function mergeMetadata<T = ProjectMetadata | TargetMetadata>(sourceMap: Record<string, [file: string, plugin: string]>, sourceInformation: [file: string, plugin: string], baseSourceMapPath: string, metadata: T, matchingMetadata?: T): T;
+export { mergeTargetConfigurations, readTargetDefaultsForTarget, } from './project-configuration/target-merging';
 export type ConfigurationResult = {
     /**
      * A map of project configurations, keyed by project root.
@@ -39,39 +37,16 @@ export type ConfigurationResult = {
  */
 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 [
+    plugin: string,
+    file: string,
+    result: CreateNodesResult,
+    pluginIndex?: number
+])[][], nxJsonConfiguration: NxJsonConfiguration, workspaceRoot: string, errors: (AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError)[]): {
+    projectRootMap: Record<string, ProjectConfiguration>;
+    externalNodes: Record<string, ProjectGraphExternalNode>;
+    rootMap: Record<string, string>;
+    configurationSourceMaps: Record<string, Record<string, SourceInformation>>;
+};
 export declare function findMatchingConfigFiles(projectFiles: string[], pattern: string, include: string[], exclude: string[]): string[];
-export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
-export declare function validateProject(project: ProjectConfiguration, knownProjects: Record<string, ProjectConfiguration>): void;
-export declare function mergeTargetDefaultWithTargetDefinition(targetName: string, project: ProjectConfiguration, targetDefault: Partial<TargetConfiguration>, sourceMap: Record<string, SourceInformation>): TargetConfiguration;
-/**
- * Merges two targets.
- *
- * Most properties from `target` will overwrite any properties from `baseTarget`.
- * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
- *
- * @param target The target definition with higher priority
- * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
- * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
- * @param sourceInformation The metadata about where the new target was defined
- * @param targetIdentifier The identifier for the target to merge, used for source map
- * @returns A merged target configuration
- */
-export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget?: TargetConfiguration, projectConfigSourceMap?: Record<string, SourceInformation>, sourceInformation?: SourceInformation, targetIdentifier?: string): TargetConfiguration;
-/**
- * Checks if targets options are compatible - used when merging configurations
- * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
- *
- * If the executors are both specified and don't match, the options aren't considered
- * "compatible" and shouldn't be merged.
- */
-export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
-export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
-export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
-/**
- * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
- * @param target The target to normalize
- * @param project The project that the target belongs to
- * @returns The normalized target configuration
- */
-export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration, workspaceRoot: string, projectsMap: Record<string, ProjectConfiguration>, errorMsgKey: string): TargetConfiguration<any>;
 //# sourceMappingURL=project-configuration-utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"project-configuration-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/utils/project-configuration-utils.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"project-configuration-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/project-graph/utils/project-configuration-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAYhF,OAAO,EACL,yBAAyB,EAMzB,eAAe,EACf,iCAAiC,EAEjC,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,KAAK,EACV,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,qCAAqC,CAAC;AAE7C,OAAO,EACL,yBAAyB,EACzB,2BAA2B,GAC5B,MAAM,wCAAwC,CAAC;AAEhD,MAAM,MAAM,mBAAmB,GAAG;IAChC;;OAEG;IACH,QAAQ,EAAE;QACR,CAAC,WAAW,EAAE,MAAM,GAAG,oBAAoB,CAAC;KAC7C,CAAC;IAEF;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,wBAAwB,CAAC,CAAC;IAExD;;OAEG;IACH,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEvC,UAAU,EAAE,uBAAuB,CAAC;IAEpC;;OAEG;IACH,oBAAoB,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAsB,sCAAsC,CAC1D,IAAI,EAAE,MAAsB,EAC5B,MAAM,EAAE,mBAAmB,EAC3B,YAAY,EAAE,MAAM,EAAE,EAAE,EAAE,wEAAwE;AAClG,OAAO,EAAE,cAAc,EAAE,GACxB,OAAO,CAAC,mBAAmB,CAAC,CAuI9B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,CAAC,SAAS;IACjB,MAAM,EAAE,MAAM;IACd,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,iBAAiB;IACzB,WAAW,CAAC,EAAE,MAAM;CACrB,CAAC,EAAE,EAAE,EACN,mBAAmB,EAAE,mBAAmB,EACxC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,CACJ,yBAAyB,GACzB,eAAe,GACf,uBAAuB,GACvB,iCAAiC,GACjC,sBAAsB,CACzB,EAAE;;;;;EAoHJ;AAoDD,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,MAAM,EAAE,EACtB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EAAE,GAChB,MAAM,EAAE,CAuBV"}