nx 19.0.0-beta.10 → 19.0.0-beta.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.0.0-beta.10",
+  "version": "19.0.0-beta.11",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -66,7 +66,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.0.0-beta.10"
+    "@nrwl/tao": "19.0.0-beta.11"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.0.0-beta.10",
-    "@nx/nx-darwin-arm64": "19.0.0-beta.10",
-    "@nx/nx-linux-x64-gnu": "19.0.0-beta.10",
-    "@nx/nx-linux-x64-musl": "19.0.0-beta.10",
-    "@nx/nx-win32-x64-msvc": "19.0.0-beta.10",
-    "@nx/nx-linux-arm64-gnu": "19.0.0-beta.10",
-    "@nx/nx-linux-arm64-musl": "19.0.0-beta.10",
-    "@nx/nx-linux-arm-gnueabihf": "19.0.0-beta.10",
-    "@nx/nx-win32-arm64-msvc": "19.0.0-beta.10",
-    "@nx/nx-freebsd-x64": "19.0.0-beta.10"
+    "@nx/nx-darwin-x64": "19.0.0-beta.11",
+    "@nx/nx-darwin-arm64": "19.0.0-beta.11",
+    "@nx/nx-linux-x64-gnu": "19.0.0-beta.11",
+    "@nx/nx-linux-x64-musl": "19.0.0-beta.11",
+    "@nx/nx-win32-x64-msvc": "19.0.0-beta.11",
+    "@nx/nx-linux-arm64-gnu": "19.0.0-beta.11",
+    "@nx/nx-linux-arm64-musl": "19.0.0-beta.11",
+    "@nx/nx-linux-arm-gnueabihf": "19.0.0-beta.11",
+    "@nx/nx-win32-arm64-msvc": "19.0.0-beta.11",
+    "@nx/nx-freebsd-x64": "19.0.0-beta.11"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -4,7 +4,7 @@ import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { ProjectGraph } from '../config/project-graph';
 export declare class ProjectGraphError extends Error {
     #private;
-    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | ProcessDependenciesError | ProcessProjectGraphError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
+    constructor(errors: Array<CreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | ProcessProjectGraphError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
     /**
      * The daemon cannot throw errors which contain methods as they are not serializable.
      *
@@ -18,23 +18,37 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError | CreateMetadataError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError)[];
+    getErrors(): (CreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | CreateMetadataError | ProcessDependenciesError | ProcessProjectGraphError | WorkspaceValidityError)[];
 }
-export declare class ProjectsWithConflictingNamesError extends Error {
+export declare class MultipleProjectsWithSameNameError extends Error {
+    conflicts: Map<string, string[]>;
     projects: Record<string, ProjectConfiguration>;
     constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>);
 }
-export declare function isProjectsWithConflictingNamesError(e: unknown): e is ProjectsWithConflictingNamesError;
+export declare class ProjectWithExistingNameError extends Error {
+    projectName: string;
+    projectRoot: string;
+    constructor(projectName: string, projectRoot: string);
+}
+export declare function isProjectWithExistingNameError(e: unknown): e is ProjectWithExistingNameError;
+export declare function isMultipleProjectsWithSameNameError(e: unknown): e is MultipleProjectsWithSameNameError;
 export declare class ProjectsWithNoNameError extends Error {
+    projectRoots: string[];
     projects: Record<string, ProjectConfiguration>;
     constructor(projectRoots: string[], projects: Record<string, ProjectConfiguration>);
 }
 export declare function isProjectsWithNoNameError(e: unknown): e is ProjectsWithNoNameError;
+export declare class ProjectWithNoNameError extends Error {
+    projectRoot: string;
+    constructor(projectRoot: string);
+}
+export declare function isProjectWithNoNameError(e: unknown): e is ProjectWithNoNameError;
 export declare class ProjectConfigurationsError extends Error {
-    readonly errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError>;
+    readonly errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>;
     readonly partialProjectConfigurationsResult: ConfigurationResult;
-    constructor(errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | ProjectsWithConflictingNamesError>, partialProjectConfigurationsResult: ConfigurationResult);
+    constructor(errors: Array<MergeNodesError | CreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError>, partialProjectConfigurationsResult: ConfigurationResult);
 }
+export declare function isProjectConfigurationsError(e: unknown): e is ProjectConfigurationsError;
 export declare class CreateNodesError extends Error {
     file: string;
     pluginName: string;

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

@@ -1,7 +1,7 @@
 "use strict";
 var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.isCreateMetadataError = exports.isAggregateProjectGraphError = exports.AggregateProjectGraphError = exports.ProcessProjectGraphError = exports.isWorkspaceValidityError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isProjectsWithConflictingNamesError = exports.ProjectsWithConflictingNamesError = exports.ProjectGraphError = void 0;
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodesError = exports.isAggregateCreateNodesError = exports.isCreateNodesError = exports.isCreateMetadataError = exports.isAggregateProjectGraphError = exports.AggregateProjectGraphError = exports.ProcessProjectGraphError = exports.isWorkspaceValidityError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.CreateNodesError = exports.isProjectConfigurationsError = exports.ProjectConfigurationsError = exports.isProjectWithNoNameError = exports.ProjectWithNoNameError = exports.isProjectsWithNoNameError = exports.ProjectsWithNoNameError = exports.isMultipleProjectsWithSameNameError = exports.isProjectWithExistingNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = void 0;
 const tslib_1 = require("tslib");
 class ProjectGraphError extends Error {
     constructor(errors, partialProjectGraph, partialSourceMaps) {
@@ -42,7 +42,7 @@ class ProjectGraphError extends Error {
 }
 exports.ProjectGraphError = ProjectGraphError;
 _ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
-class ProjectsWithConflictingNamesError extends Error {
+class MultipleProjectsWithSameNameError extends Error {
     constructor(conflicts, projects) {
         super([
             `The following projects are defined in multiple locations:`,
@@ -50,21 +50,39 @@ class ProjectsWithConflictingNamesError extends Error {
             '',
             "To fix this, set a unique name for each project in a project.json inside the project's root. If the project does not currently have a project.json, you can create one that contains only a name.",
         ].join('\n'));
+        this.conflicts = conflicts;
         this.projects = projects;
         this.name = this.constructor.name;
     }
 }
-exports.ProjectsWithConflictingNamesError = ProjectsWithConflictingNamesError;
-function isProjectsWithConflictingNamesError(e) {
-    return (e instanceof ProjectsWithConflictingNamesError ||
+exports.MultipleProjectsWithSameNameError = MultipleProjectsWithSameNameError;
+class ProjectWithExistingNameError extends Error {
+    constructor(projectName, projectRoot) {
+        super(`The project "${projectName}" is defined in multiple locations.`);
+        this.projectName = projectName;
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithExistingNameError = ProjectWithExistingNameError;
+function isProjectWithExistingNameError(e) {
+    return (e instanceof ProjectWithExistingNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithExistingNameError.name));
+}
+exports.isProjectWithExistingNameError = isProjectWithExistingNameError;
+function isMultipleProjectsWithSameNameError(e) {
+    return (e instanceof MultipleProjectsWithSameNameError ||
         (typeof e === 'object' &&
             'name' in e &&
-            e?.name === ProjectsWithConflictingNamesError.prototype.name));
+            e?.name === MultipleProjectsWithSameNameError.name));
 }
-exports.isProjectsWithConflictingNamesError = isProjectsWithConflictingNamesError;
+exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameError;
 class ProjectsWithNoNameError extends Error {
     constructor(projectRoots, projects) {
         super(`The projects in the following directories have no name provided:\n  - ${projectRoots.join('\n  - ')}`);
+        this.projectRoots = projectRoots;
         this.projects = projects;
         this.name = this.constructor.name;
     }
@@ -74,9 +92,24 @@ function isProjectsWithNoNameError(e) {
     return (e instanceof ProjectsWithNoNameError ||
         (typeof e === 'object' &&
             'name' in e &&
-            e?.name === ProjectsWithNoNameError.prototype.name));
+            e?.name === ProjectsWithNoNameError.name));
 }
 exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
+class ProjectWithNoNameError extends Error {
+    constructor(projectRoot) {
+        super(`The project in ${projectRoot} has no name provided.`);
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithNoNameError = ProjectWithNoNameError;
+function isProjectWithNoNameError(e) {
+    return (e instanceof ProjectWithNoNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithNoNameError.name));
+}
+exports.isProjectWithNoNameError = isProjectWithNoNameError;
 class ProjectConfigurationsError extends Error {
     constructor(errors, partialProjectConfigurationsResult) {
         super('Failed to create project configurations');
@@ -86,6 +119,13 @@ class ProjectConfigurationsError extends Error {
     }
 }
 exports.ProjectConfigurationsError = ProjectConfigurationsError;
+function isProjectConfigurationsError(e) {
+    return (e instanceof ProjectConfigurationsError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectConfigurationsError.name));
+}
+exports.isProjectConfigurationsError = isProjectConfigurationsError;
 class CreateNodesError extends Error {
     constructor({ file, pluginName, error, }) {
         const msg = `The "${pluginName}" plugin threw an error while creating nodes from ${file}:`;
@@ -180,14 +220,14 @@ function isAggregateProjectGraphError(e) {
     return (e instanceof AggregateProjectGraphError ||
         (typeof e === 'object' &&
             'name' in e &&
-            e?.name === AggregateProjectGraphError.prototype.name));
+            e?.name === AggregateProjectGraphError.name));
 }
 exports.isAggregateProjectGraphError = isAggregateProjectGraphError;
 function isCreateMetadataError(e) {
     return (e instanceof CreateMetadataError ||
         (typeof e === 'object' &&
             'name' in e &&
-            e?.name === CreateMetadataError.prototype.name));
+            e?.name === CreateMetadataError.name));
 }
 exports.isCreateMetadataError = isCreateMetadataError;
 function isCreateNodesError(e) {

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

@@ -43,6 +43,7 @@ export type ConfigurationResult = {
 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: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+export declare function validateProject(project: ProjectConfiguration, knownProjects: Record<string, ProjectConfiguration>): void;
 /**
  * Merges two targets.
  *

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeTarget = exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeMetadata = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.normalizeTarget = exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.validateProject = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeMetadata = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const logger_1 = require("../../utils/logger");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
@@ -131,7 +131,7 @@ skipTargetNormalization) {
             }
             const normalizedTarget = skipTargetNormalization
                 ? target
-                : normalizeTarget(target, project);
+                : resolveCommandSyntacticSugar(target, project.root);
             const mergedTarget = mergeTargetConfigurations(normalizedTarget, matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
             // We don't want the symbol to live on past the merge process
             if (mergedTarget?.[symbols_1.ONLY_MODIFIES_EXISTING_TARGET])
@@ -295,16 +295,11 @@ plugins) {
             Object.assign(externalNodes, pluginExternalNodes);
         }
         try {
-            // We still call this just to assert that the root map
-            // only contains valid project names. This is a safety check.
-            //
-            // The signature itself can't be changed as we need it to return
-            // project configurations for use in devkit.
-            readProjectConfigurationsFromRootMap(projectRootMap);
+            validateAndNormalizeProjectRootMap(projectRootMap);
         }
         catch (e) {
             if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
-                (0, error_types_1.isProjectsWithConflictingNamesError)(e)) {
+                (0, error_types_1.isMultipleProjectsWithSameNameError)(e)) {
                 errors.push(e);
             }
             else {
@@ -345,37 +340,33 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     const conflicts = new Map();
     const projectRootsWithNoName = [];
     for (const root in projectRootMap) {
-        const configuration = projectRootMap[root];
+        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 (configuration['// targets'])
-            delete configuration['// targets'];
-        if (!configuration.name) {
-            try {
-                const { name } = (0, fileutils_1.readJsonFile)((0, path_1.join)(root, 'package.json'));
-                if (!name) {
-                    throw new Error("No name found for project at '" + root + "'.");
-                }
-                configuration.name = name;
+        if (project['// targets'])
+            delete project['// targets'];
+        try {
+            validateProject(project, projects);
+            projects[project.name] = project;
+        }
+        catch (e) {
+            if ((0, error_types_1.isProjectWithNoNameError)(e)) {
+                projectRootsWithNoName.push(e.projectRoot);
             }
-            catch {
-                projectRootsWithNoName.push(root);
+            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;
             }
-        }
-        if (configuration.name in projects) {
-            let rootErrors = conflicts.get(configuration.name) ?? [
-                projects[configuration.name].root,
-            ];
-            rootErrors.push(root);
-            conflicts.set(configuration.name, rootErrors);
-            projects[configuration.name] = configuration;
-        }
-        else {
-            projects[configuration.name] = configuration;
         }
     }
     if (conflicts.size > 0) {
-        throw new error_types_1.ProjectsWithConflictingNamesError(conflicts, projects);
+        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
     }
     if (projectRootsWithNoName.length > 0) {
         throw new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects);
@@ -383,6 +374,76 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+function validateAndNormalizeProjectRootMap(projectRootMap) {
+    // 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 = [];
+    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'];
+        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 targetName in project.targets) {
+            project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
+            if (!project.targets[targetName].executor &&
+                !project.targets[targetName].command) {
+                delete project.targets[targetName];
+            }
+        }
+    }
+    if (conflicts.size > 0) {
+        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
+    }
+    if (projectRootsWithNoName.length > 0) {
+        throw new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects);
+    }
+    return projectRootMap;
+}
+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);
+    }
+}
+exports.validateProject = validateProject;
 /**
  * Merges two targets.
  *