nx 19.3.0-canary.20240607-7495f06 → 19.3.0-canary.20240611-1600875

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

@@ -147,7 +147,7 @@ function readAndCombineAllProjectConfigurations(tree) {
         }
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, json_1.readJson)(tree, projectFile);
-            const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, projectFile, (0, nx_json_1.readNxJson)(tree));
+            const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, tree.root, projectFile, (0, nx_json_1.readNxJson)(tree));
             if (!rootMap[config.root]) {
                 (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
                 // Inferred targets, tags, etc don't show up when running generators

package/src/hasher/file-hasher.js

@@ -10,7 +10,7 @@ exports.hashArray = hashArray;
 function hashObject(obj) {
     const { hashArray } = require('../native');
     const parts = [];
-    for (const key of Object.keys(obj).sort()) {
+    for (const key of Object.keys(obj ?? {}).sort()) {
         parts.push(key);
         parts.push(JSON.stringify(obj[key]));
     }

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TargetProjectLocator = exports.isBuiltinModuleImport = void 0;
 const node_module_1 = require("node:module");
 const node_path_1 = require("node:path");
+const semver_1 = require("semver");
 const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
 const fileutils_1 = require("../../../../utils/fileutils");
 const workspace_root_1 = require("../../../../utils/workspace-root");
@@ -138,7 +139,8 @@ class TargetProjectLocator {
                 this.npmResolutionCache.set(npmImportForProject, externalNodeName);
                 return externalNodeName;
             }
-            const npmProjectKey = `npm:${externalPackageJson.name}@${externalPackageJson.version}`;
+            const version = (0, semver_1.clean)(externalPackageJson.version);
+            const npmProjectKey = `npm:${externalPackageJson.name}@${version}`;
             const matchingExternalNode = this.npmProjects[npmProjectKey];
             if (!matchingExternalNode) {
                 return null;

package/src/plugins/package-json-workspaces/create-nodes.d.ts

@@ -4,14 +4,14 @@ import { PackageJson } from '../../utils/package-json';
 import { CreateNodes } from '../../project-graph/plugins';
 export declare const createNodes: CreateNodes;
 export declare function buildPackageJsonWorkspacesMatcher(workspaceRoot: string, readJson: (string: any) => any): (p: string) => boolean;
-export declare function createNodeFromPackageJson(pkgJsonPath: string, root: string): {
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string): {
     projects: {
         [x: string]: ProjectConfiguration & {
             name: string;
         };
     };
 };
-export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, path: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {
+export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {
     name: string;
 };
 /**

package/src/plugins/package-json-workspaces/create-nodes.js

@@ -38,12 +38,21 @@ function buildPackageJsonWorkspacesMatcher(workspaceRoot, readJson) {
         positivePatterns.push('**/package.json');
     }
     return (p) => positivePatterns.some((positive) => (0, minimatch_1.minimatch)(p, positive)) &&
-        !negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative));
+        /**
+         * minimatch will return true if the given p is NOT excluded by the negative pattern.
+         *
+         * For example if the negative pattern is "!packages/vite", then the given p "packages/vite" will return false,
+         * the given p "packages/something-else/package.json" will return true.
+         *
+         * Therefore, we need to ensure that every negative pattern returns true to validate that the given p is not
+         * excluded by any of the negative patterns.
+         */
+        negativePatterns.every((negative) => (0, minimatch_1.minimatch)(p, negative));
 }
 exports.buildPackageJsonWorkspacesMatcher = buildPackageJsonWorkspacesMatcher;
-function createNodeFromPackageJson(pkgJsonPath, root) {
-    const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, pkgJsonPath));
-    const project = buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root));
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot) {
+    const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot));
     return {
         projects: {
             [project.root]: project,
@@ -51,21 +60,27 @@ function createNodeFromPackageJson(pkgJsonPath, root) {
     };
 }
 exports.createNodeFromPackageJson = createNodeFromPackageJson;
-function buildProjectConfigurationFromPackageJson(packageJson, path, nxJson) {
-    const normalizedPath = path.split('\\').join('/');
-    const directory = (0, node_path_1.dirname)(normalizedPath);
-    if (!packageJson.name && directory === '.') {
+function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson) {
+    const normalizedPath = packageJsonPath.split('\\').join('/');
+    const projectRoot = (0, node_path_1.dirname)(normalizedPath);
+    const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
+    if (siblingProjectJson) {
+        for (const target of Object.keys(siblingProjectJson?.targets ?? {})) {
+            delete packageJson.scripts?.[target];
+        }
+    }
+    if (!packageJson.name && projectRoot === '.') {
         throw new Error('Nx requires the root package.json to specify a name if it is being used as an Nx project.');
     }
     let name = packageJson.name ?? (0, to_project_name_1.toProjectName)(normalizedPath);
     const projectType = nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
         nxJson?.workspaceLayout?.appsDir &&
-        directory.startsWith(nxJson.workspaceLayout.appsDir)
+        projectRoot.startsWith(nxJson.workspaceLayout.appsDir)
         ? 'application'
         : 'library';
     return {
-        root: directory,
-        sourceRoot: directory,
+        root: projectRoot,
+        sourceRoot: projectRoot,
         name,
         projectType,
         ...packageJson.nx,
@@ -127,3 +142,11 @@ function normalizePatterns(patterns) {
 function removeRelativePath(pattern) {
     return pattern.startsWith('./') ? pattern.substring(2) : pattern;
 }
+function tryReadJson(path) {
+    try {
+        return (0, fileutils_1.readJsonFile)(path);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -161,6 +161,16 @@ class AggregateCreateNodesError extends Error {
         this.errors = errors;
         this.partialResults = partialResults;
         this.name = this.constructor.name;
+        if (
+        // Errors should be an array
+        !Array.isArray(errors) ||
+            !errors.every(
+            // Where every element is a tuple
+            (errorTuple) => Array.isArray(errorTuple) &&
+                // That has a length of 2
+                errorTuple.length === 2)) {
+            throw new Error('AggregateCreateNodesError must be constructed with an array of tuples where the first element is a filename or undefined and the second element is the underlying error.');
+        }
     }
 }
 exports.AggregateCreateNodesError = AggregateCreateNodesError;

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

@@ -162,7 +162,7 @@ function getProjectsSync(root, nxJson) {
         }
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, fileutils_1.readJsonFile)(projectFile);
-            const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, projectFile, nxJson);
+            const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, root, projectFile, nxJson);
             if (!rootMap[config.root]) {
                 (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
                 // Inferred targets, tags, etc don't show up when running generators

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

@@ -45,7 +45,7 @@ class LoadedNxPlugin {
                         throw e;
                     }
                     // The underlying plugin errored out. We can't know any partial results.
-                    throw new error_types_1.AggregateCreateNodesError([null, e], []);
+                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
                 }
                 finally {
                     performance.mark(`${plugin.name}:createNodes - end`);

package/src/project-graph/utils/normalize-project-nodes.js

@@ -76,11 +76,29 @@ function normalizeImplicitDependencies(source, implicitDependencies, projects) {
     if (!implicitDependencies?.length) {
         return implicitDependencies ?? [];
     }
-    const matches = (0, find_matching_projects_1.findMatchingProjects)(implicitDependencies, projects);
-    return (matches
-        .filter((x) => x !== source)
-        // implicit dependencies that start with ! should hang around, to be processed by
-        // implicit-project-dependencies.ts after explicit deps are added to graph.
-        .concat(implicitDependencies.filter((x) => x.startsWith('!'))));
+    // Implicit dependencies handle negatives in a different
+    // way from most other `projects` fields. This is because
+    // they are used for multiple purposes.
+    const positivePatterns = [];
+    const negativePatterns = [];
+    for (const dep of implicitDependencies) {
+        if (dep.startsWith('!')) {
+            negativePatterns.push(dep);
+        }
+        else {
+            positivePatterns.push(dep);
+        }
+    }
+    // Finds all projects that match a positive pattern and are not excluded by a negative pattern
+    const deps = positivePatterns.length
+        ? (0, find_matching_projects_1.findMatchingProjects)(positivePatterns.concat(negativePatterns), projects).filter((x) => x !== source)
+        : [];
+    // Expands negative patterns to equal project names
+    const alwaysIgnoredDeps = (0, find_matching_projects_1.findMatchingProjects)(negativePatterns.map((x) => x.slice(1)), projects);
+    // We return the matching deps, but keep the negative patterns in the list
+    // so that they can be processed later by implicit-project-dependencies.ts
+    // This is what allows using a negative implicit dep to remove a dependency
+    // detected by createDependencies.
+    return deps.concat(alwaysIgnoredDeps.map((x) => '!' + x));
 }
 exports.normalizeImplicitDependencies = normalizeImplicitDependencies;

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

@@ -245,7 +245,15 @@ plugins) {
                     e
                 : // This represents a single plugin erroring out with a hard error.
                     new error_types_1.AggregateCreateNodesError([[null, e]], []);
-            errorBodyLines.push(...error.errors.map(([file, e]) => `  - ${file}: ${e.message}`));
+            const innerErrors = error.errors;
+            for (const [file, e] of innerErrors) {
+                if (file) {
+                    errorBodyLines.push(`  - ${file}: ${e.message}`);
+                }
+                else {
+                    errorBodyLines.push(`  - ${e.message}`);
+                }
+            }
             error.message = errorBodyLines.join('\n');
             // This represents a single plugin erroring out with a hard error.
             errors.push(error);

package/src/tasks-runner/create-task-graph.js

@@ -64,7 +64,26 @@ class ProcessTasks {
                 ? overrides
                 : { __overrides_unparsed__: [] };
             if (dependencyConfig.projects) {
-                this.processTasksForMatchingProjects(dependencyConfig, projectUsedToDeriveDependencies, configuration, task, taskOverrides, overrides);
+                /** LERNA SUPPORT START - Remove in v20 */
+                // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
+                // support for it until lerna can be updated to use the syntax.
+                //
+                // This should have been removed in v17, but the updates to lerna had not
+                // been made yet.
+                //
+                // TODO(@agentender): Remove this part in v20
+                if (typeof dependencyConfig.projects === 'string') {
+                    if (dependencyConfig.projects === 'self') {
+                        this.processTasksForSingleProject(task, task.target.project, dependencyConfig, configuration, taskOverrides, overrides);
+                        continue;
+                    }
+                    else if (dependencyConfig.projects === 'dependencies') {
+                        this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
+                        continue;
+                    }
+                }
+                /** LERNA SUPPORT END - Remove in v17 */
+                this.processTasksForMatchingProjects(dependencyConfig, configuration, task, taskOverrides, overrides);
             }
             else if (dependencyConfig.dependencies) {
                 this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
@@ -74,41 +93,21 @@ class ProcessTasks {
             }
         }
     }
-    processTasksForMatchingProjects(dependencyConfig, projectUsedToDeriveDependencies, configuration, task, taskOverrides, overrides) {
+    processTasksForMatchingProjects(dependencyConfig, configuration, task, taskOverrides, overrides) {
         const targetProjectSpecifiers = typeof dependencyConfig.projects === 'string'
             ? [dependencyConfig.projects]
             : dependencyConfig.projects;
-        for (const projectSpecifier of targetProjectSpecifiers) {
-            // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
-            // support for it until lerna can be updated to use the syntax.
-            // TODO(@agentender): Remove this part in v17
-            if (projectSpecifier === 'dependencies' &&
-                !this.projectGraph.nodes[projectSpecifier]) {
-                this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
-            }
-            else {
-                // Since we need to maintain support for dependencies, it is more coherent
-                // that we also support self.
-                // TODO(@agentender): Remove this part in v17
-                const matchingProjects = 
-                /** LERNA SUPPORT START - Remove in v17 */
-                projectSpecifier === 'self' &&
-                    !this.projectGraph.nodes[projectSpecifier]
-                    ? [task.target.project]
-                    : /** LERNA SUPPORT END */
-                        (0, find_matching_projects_1.findMatchingProjects)([projectSpecifier], this.projectGraph.nodes);
-                if (matchingProjects.length === 0) {
-                    output_1.output.warn({
-                        title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
-                        bodyLines: [
-                            `Project pattern "${projectSpecifier}" does not match any projects.`,
-                        ],
-                    });
-                }
-                for (const projectName of matchingProjects) {
-                    this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
-                }
-            }
+        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(targetProjectSpecifiers, this.projectGraph.nodes);
+        if (matchingProjects.length === 0) {
+            output_1.output.warn({
+                title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
+                bodyLines: [
+                    `Project patterns "${targetProjectSpecifiers}" does not match any projects.`,
+                ],
+            });
+        }
+        for (const projectName of matchingProjects) {
+            this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
         }
     }
     processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides) {

package/src/utils/ab-testing.d.ts

@@ -31,7 +31,7 @@ declare const messageOptions: {
     }];
 };
 export type MessageKey = keyof typeof messageOptions;
-export type MessageData = typeof messageOptions[MessageKey][number];
+export type MessageData = (typeof messageOptions)[MessageKey][number];
 export declare class PromptMessages {
     private selectedMessages;
     getPrompt(key: MessageKey): MessageData;

package/src/utils/find-matching-projects.js

@@ -22,6 +22,15 @@ function findMatchingProjects(patterns = [], projects) {
     }
     const projectNames = Object.keys(projects);
     const matchedProjects = new Set();
+    // If the first pattern is an exclude pattern,
+    // we add a wildcard pattern at the first to select
+    // all projects, except the ones that match the exclude pattern.
+    // e.g. ['!tag:someTag', 'project2'] will match all projects except
+    // the ones with the tag 'someTag', and also match the project 'project2',
+    // regardless of its tags.
+    if (isExcludePattern(patterns[0])) {
+        patterns.unshift('*');
+    }
     for (const stringPattern of patterns) {
         if (!stringPattern.length) {
             continue;
@@ -139,8 +148,11 @@ function addMatchingProjectsByTag(projectNames, projects, pattern, matchedProjec
         }
     }
 }
+function isExcludePattern(pattern) {
+    return pattern.startsWith('!');
+}
 function parseStringPattern(pattern, projects) {
-    const isExclude = pattern.startsWith('!');
+    const isExclude = isExcludePattern(pattern);
     // Support for things like: `!{type}:value`
     if (isExclude) {
         pattern = pattern.substring(1);