nx 19.3.0-beta.0 → 19.3.0-beta.1

package/src/daemon/client/client.js

@@ -19,7 +19,6 @@ const nx_json_1 = require("../../config/nx-json");
 const daemon_socket_messenger_1 = require("./daemon-socket-messenger");
 const cache_1 = require("../cache");
 const error_types_1 = require("../../project-graph/error-types");
-const dotenv_1 = require("../../utils/dotenv");
 const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
 const get_context_file_data_1 = require("../message-types/get-context-file-data");
 const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
@@ -41,7 +40,6 @@ class DaemonClient {
         this._daemonReady = null;
         this._out = null;
         this._err = null;
-        (0, dotenv_1.loadRootEnvFiles)(workspace_root_1.workspaceRoot);
         try {
             this.nxJson = (0, configuration_1.readNxJson)();
         }

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -19,7 +19,7 @@ export interface RunCommandsOptions extends Json {
     } | string)[];
     color?: boolean;
     parallel?: boolean;
-    readyWhen?: string;
+    readyWhen?: string | string[];
     cwd?: string;
     env?: Record<string, string>;
     forwardAllArgs?: boolean;
@@ -42,9 +42,13 @@ export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
         [k: string]: any;
     };
     unparsedCommandArgs?: {
-        [k: string]: string;
+        [k: string]: string | string[];
     };
     args?: string;
+    readyWhenStatus: {
+        stringToMatch: string;
+        found: boolean;
+    }[];
 }
 export default function (options: RunCommandsOptions, context: ExecutorContext): Promise<{
     success: boolean;

package/src/executors/run-commands/run-commands.impl.js

@@ -29,7 +29,9 @@ const propKeys = [
     'command',
     'commands',
     'color',
+    'no-color',
     'parallel',
+    'no-parallel',
     'readyWhen',
     'cwd',
     'args',
@@ -48,7 +50,7 @@ async function default_1(options, context) {
         await loadEnvVars(options.envFile);
     }
     const normalized = normalizeOptions(options);
-    if (options.readyWhen && !options.parallel) {
+    if (normalized.readyWhenStatus.length && !normalized.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
     }
     if (options.commands.find((c) => c.prefix || c.color || c.bgColor) &&
@@ -70,12 +72,12 @@ async function default_1(options, context) {
 }
 exports.default = default_1;
 async function runInParallel(options, context) {
-    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhen, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput, options.tty).then((result) => ({
+    const procs = options.commands.map((c) => createProcess(null, c, options.readyWhenStatus, options.color, calculateCwd(options.cwd, context), options.env ?? {}, true, options.usePty, options.streamOutput, options.tty).then((result) => ({
         result,
         command: c.command,
     })));
     let terminalOutput = '';
-    if (options.readyWhen) {
+    if (options.readyWhenStatus.length) {
         const r = await Promise.race(procs);
         terminalOutput += r.result.terminalOutput;
         if (!r.result.success) {
@@ -116,9 +118,21 @@ async function runInParallel(options, context) {
     }
 }
 function normalizeOptions(options) {
+    if (options.readyWhen && typeof options.readyWhen === 'string') {
+        options.readyWhenStatus = [
+            { stringToMatch: options.readyWhen, found: false },
+        ];
+    }
+    else {
+        options.readyWhenStatus =
+            options.readyWhen?.map((stringToMatch) => ({
+                stringToMatch,
+                found: false,
+            })) ?? [];
+    }
     if (options.command) {
         options.commands = [{ command: options.command }];
-        options.parallel = !!options.readyWhen;
+        options.parallel = options.readyWhenStatus?.length > 0;
     }
     else {
         options.commands = options.commands.map((c) => typeof c === 'string' ? { command: c } : c);
@@ -131,6 +145,7 @@ function normalizeOptions(options) {
             'parse-numbers': false,
             'parse-positional-numbers': false,
             'dot-notation': false,
+            'camel-case-expansion': false,
         },
     });
     options.unknownOptions = Object.keys(options)
@@ -147,7 +162,7 @@ async function runSerially(options, context) {
     pseudoTerminal ??= pseudo_terminal_1.PseudoTerminal.isSupported() ? (0, pseudo_terminal_1.getPseudoTerminal)() : null;
     let terminalOutput = '';
     for (const c of options.commands) {
-        const result = await createProcess(pseudoTerminal, c, undefined, options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput, options.tty);
+        const result = await createProcess(pseudoTerminal, c, [], options.color, calculateCwd(options.cwd, context), options.env ?? {}, false, options.usePty, options.streamOutput, options.tty);
         terminalOutput += result.terminalOutput;
         if (!result.success) {
             const output = `Warning: command "${c.command}" exited with non-zero status code`;
@@ -160,13 +175,14 @@ async function runSerially(options, context) {
     }
     return { success: true, terminalOutput };
 }
-async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cwd, env, isParallel, usePty = true, streamOutput = true, tty) {
+async function createProcess(pseudoTerminal, commandConfig, readyWhenStatus = [], color, cwd, env, isParallel, usePty = true, streamOutput = true, tty) {
     env = processEnv(color, cwd, env);
     // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
     // currently does not work properly in windows
     if (pseudoTerminal &&
         process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
         !commandConfig.prefix &&
+        readyWhenStatus.length === 0 &&
         !isParallel &&
         usePty) {
         let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
@@ -183,9 +199,6 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
         return new Promise((res) => {
             cp.onOutput((output) => {
                 terminalOutput += output;
-                if (readyWhen && output.indexOf(readyWhen) > -1) {
-                    res({ success: true, terminalOutput });
-                }
             });
             cp.onExit((code) => {
                 if (code >= 128) {
@@ -197,9 +210,9 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
             });
         });
     }
-    return nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput);
+    return nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput);
 }
-function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
+function nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput = true) {
     let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
     if (streamOutput) {
         process.stdout.write(terminalOutput);
@@ -217,7 +230,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
             if (streamOutput) {
                 process.stdout.write(output);
             }
-            if (readyWhen && data.toString().indexOf(readyWhen) > -1) {
+            if (readyWhenStatus.length && isReady(readyWhenStatus, data.toString())) {
                 res({ success: true, terminalOutput });
             }
         });
@@ -227,7 +240,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
             if (streamOutput) {
                 process.stderr.write(output);
             }
-            if (readyWhen && err.toString().indexOf(readyWhen) > -1) {
+            if (readyWhenStatus.length && isReady(readyWhenStatus, err.toString())) {
                 res({ success: true, terminalOutput });
             }
         });
@@ -241,7 +254,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
         });
         childProcess.on('exit', (code) => {
             childProcesses.delete(childProcess);
-            if (!readyWhen) {
+            if (!readyWhenStatus.length || isReady(readyWhenStatus)) {
                 res({ success: code === 0, terminalOutput });
             }
         });
@@ -294,20 +307,21 @@ function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
     else if (forwardAllArgs) {
         let args = '';
         if (Object.keys(opts.unknownOptions ?? {}).length > 0) {
-            args +=
-                ' ' +
-                    Object.keys(opts.unknownOptions)
-                        .filter((k) => typeof opts.unknownOptions[k] !== 'object' &&
-                        opts.parsedArgs[k] === opts.unknownOptions[k])
-                        .map((k) => `--${k}=${opts.unknownOptions[k]}`)
-                        .map(wrapArgIntoQuotesIfNeeded)
-                        .join(' ');
+            const unknownOptionsArgs = Object.keys(opts.unknownOptions)
+                .filter((k) => typeof opts.unknownOptions[k] !== 'object' &&
+                opts.parsedArgs[k] === opts.unknownOptions[k])
+                .map((k) => `--${k}=${opts.unknownOptions[k]}`)
+                .map(wrapArgIntoQuotesIfNeeded)
+                .join(' ');
+            if (unknownOptionsArgs) {
+                args += ` ${unknownOptionsArgs}`;
+            }
         }
         if (opts.args) {
             args += ` ${opts.args}`;
         }
         if (opts.__unparsed__?.length > 0) {
-            const filterdParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.unparsedCommandArgs);
+            const filterdParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.parsedArgs);
             if (filterdParsedOptions.length > 0) {
                 args += ` ${filterdParsedOptions
                     .map(wrapArgIntoQuotesIfNeeded)
@@ -335,13 +349,14 @@ function parseArgs(unparsedCommandArgs, unknownOptions, args) {
  * @param unparsedCommandArgs e.g. { prop1: 'value1', prop2: 'value2', args: 'test'}
  * @returns filtered options that are not part of the propKeys array e.g. ['--prop1', 'value1', '--prop2=value2']
  */
-function filterPropKeysFromUnParsedOptions(__unparsed__, unparsedCommandArgs = {}) {
+function filterPropKeysFromUnParsedOptions(__unparsed__, parseArgs = {}) {
     const parsedOptions = [];
     for (let index = 0; index < __unparsed__.length; index++) {
         const element = __unparsed__[index];
         if (element.startsWith('--')) {
             const key = element.replace('--', '');
             if (element.includes('=')) {
+                // key can be in the format of --key=value or --key.subkey=value (e.g. env.foo=bar)
                 if (!propKeys.includes(key.split('=')[0].split('.')[0])) {
                     // check if the key is part of the propKeys array
                     parsedOptions.push(element);
@@ -351,7 +366,8 @@ function filterPropKeysFromUnParsedOptions(__unparsed__, unparsedCommandArgs = {
                 // check if the next element is a value for the key
                 if (propKeys.includes(key)) {
                     if (index + 1 < __unparsed__.length &&
-                        __unparsed__[index + 1] === unparsedCommandArgs[key]) {
+                        parseArgs[key] &&
+                        __unparsed__[index + 1].toString() === parseArgs[key].toString()) {
                         index++; // skip the next element
                     }
                 }
@@ -437,3 +453,14 @@ function wrapArgIntoQuotesIfNeeded(arg) {
         return arg;
     }
 }
+function isReady(readyWhenStatus = [], data) {
+    if (data) {
+        for (const readyWhenElement of readyWhenStatus) {
+            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
+                readyWhenElement.found = true;
+                break;
+            }
+        }
+    }
+    return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
+}

package/src/executors/run-commands/schema.json

@@ -95,8 +95,11 @@
       "x-priority": "important"
     },
     "readyWhen": {
-      "type": "string",
-      "description": "String to appear in `stdout` or `stderr` that indicates that the task is done. When running multiple commands, this option can only be used when `parallel` is set to `true`. If not specified, the task is done when all the child processes complete."
+      "description": "String or array of strings to appear in `stdout` or `stderr` that indicate that the task is done. When running multiple commands, this option can only be used when `parallel` is set to `true`. If not specified, the task is done when all the child processes complete.",
+      "oneOf": [
+        { "type": "string" },
+        { "type": "array", "items": { "type": "string" } }
+      ]
     },
     "args": {
       "oneOf": [

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/migrations/update-19-2-4/set-project-name.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function setProjectName(tree: Tree): Promise<void>;

package/src/migrations/update-19-2-4/set-project-name.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const to_project_name_1 = require("../../config/to-project-name");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const json_1 = require("../../generators/utils/json");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+async function setProjectName(tree) {
+    // We are explicitly looking for project.json files here, so getProjects is fine.
+    const projects = (0, project_configuration_1.getProjects)(tree);
+    for (const { root } of projects.values()) {
+        const projectJsonPath = `${root}/project.json`;
+        const packageJsonPath = `${root}/package.json`;
+        // If either of these files doesn't exist, theres no behavioral difference
+        if (!tree.exists(projectJsonPath) || !tree.exists(packageJsonPath)) {
+            continue;
+        }
+        const projectJson = (0, json_1.readJson)(tree, projectJsonPath);
+        // In Nx 19.1+, the way the project name is inferred is different.
+        // For existing projects, if the name is not set, we can inline it
+        // based on the existing logic. This makes sure folks aren't caught
+        // off guard by the new behavior.
+        if (!projectJson.name) {
+            const siblingPackageJson = (0, json_1.readJson)(tree, packageJsonPath);
+            const newName = siblingPackageJson.nx?.name ?? siblingPackageJson.name;
+            const oldName = (0, to_project_name_1.toProjectName)(projectJsonPath);
+            if (newName && oldName !== newName) {
+                projectJson.name = oldName;
+                (0, json_1.writeJson)(tree, projectJsonPath, projectJson);
+            }
+        }
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+exports.default = setProjectName;

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

@@ -46,6 +46,9 @@ function createPackageJson(projectName, graph, options = {}, fileMap = null) {
                 delete packageJson.dependencies;
                 delete packageJson.devDependencies;
             }
+            if (options.isProduction) {
+                delete packageJson.devDependencies;
+            }
         }
         catch (e) { }
     }

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;
@@ -244,12 +246,15 @@ class TargetProjectLocator {
         // The package.json is directly resolvable
         const packageJsonPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)((0, node_path_1.join)(packageName, 'package.json'), relativeToDir);
         if (packageJsonPath) {
-            return (0, fileutils_1.readJsonFile)(packageJsonPath);
+            const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+            if (parsedPackageJson.name && parsedPackageJson.version) {
+                return parsedPackageJson;
+            }
         }
         try {
             // Resolve the main entry point of the package
-            const mainPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)(packageName, relativeToDir);
-            let dir = (0, node_path_1.dirname)(mainPath);
+            const pathOfFileInPackage = packageJsonPath ?? (0, resolve_relative_to_dir_1.resolveRelativeToDir)(packageName, relativeToDir);
+            let dir = (0, node_path_1.dirname)(pathOfFileInPackage);
             while (dir !== (0, node_path_1.parse)(dir).root) {
                 const packageJsonPath = (0, node_path_1.join)(dir, 'package.json');
                 try {

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/plugins/project-json/build-nodes/project-json.d.ts

@@ -3,3 +3,4 @@ import { NxPluginV2 } from '../../../project-graph/plugins';
 export declare const ProjectJsonProjectsPlugin: NxPluginV2;
 export default ProjectJsonProjectsPlugin;
 export declare function buildProjectFromProjectJson(json: Partial<ProjectConfiguration>, path: string): ProjectConfiguration;
+export declare function readNameFromPackageJson(path: string): string;

package/src/plugins/project-json/build-nodes/project-json.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildProjectFromProjectJson = exports.ProjectJsonProjectsPlugin = void 0;
+exports.readNameFromPackageJson = exports.buildProjectFromProjectJson = exports.ProjectJsonProjectsPlugin = void 0;
 const node_path_1 = require("node:path");
 const to_project_name_1 = require("../../../config/to-project-name");
 const fileutils_1 = require("../../../utils/fileutils");
@@ -21,10 +21,22 @@ exports.ProjectJsonProjectsPlugin = {
 };
 exports.default = exports.ProjectJsonProjectsPlugin;
 function buildProjectFromProjectJson(json, path) {
+    const packageJsonPath = (0, node_path_1.join)((0, node_path_1.dirname)(path), 'package.json');
+    const { name, root, ...rest } = json;
     return {
-        name: (0, to_project_name_1.toProjectName)(path),
-        root: (0, node_path_1.dirname)(path),
-        ...json,
+        name: name ?? readNameFromPackageJson(packageJsonPath) ?? (0, to_project_name_1.toProjectName)(path),
+        root: root ?? (0, node_path_1.dirname)(path),
+        ...rest,
     };
 }
 exports.buildProjectFromProjectJson = buildProjectFromProjectJson;
+function readNameFromPackageJson(path) {
+    try {
+        const json = (0, fileutils_1.readJsonFile)(path);
+        return json.nx?.name ?? json.name;
+    }
+    catch {
+        return undefined;
+    }
+}
+exports.readNameFromPackageJson = readNameFromPackageJson;

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);