nx 19.3.0-canary.20240612-4a5eb23 → 19.3.0

package/migrations.json

@@ -83,6 +83,12 @@
       "version": "19.2.2-beta.0",
       "description": "Updates the nx wrapper.",
       "implementation": "./src/migrations/update-17-3-0/update-nxw"
+    },
+    "19-2-4-set-project-name": {
+      "version": "19.2.4-beta.0",
+      "description": "Set project name in nx.json explicitly",
+      "implementation": "./src/migrations/update-19-2-4/set-project-name",
+      "x-repair-skip": true
     }
   }
 }

package/package.json

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

package/src/command-line/release/command-object.js

@@ -101,7 +101,7 @@ const versionCommand = {
     })
         .option('preid', {
         type: 'string',
-        describe: 'The optional prerelease identifier to apply to the version, in the case that the specifier argument has been set to `prerelease`.',
+        describe: 'The optional prerelease identifier to apply to the version. This will only be applied in the case that the specifier argument has been set to `prerelease` OR when conventional commits are enabled, in which case it will modify the resolved specifier from conventional commits to be its prerelease equivalent. E.g. minor -> preminor',
         default: '',
     })
         .option('stage-changes', {

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;
@@ -45,6 +45,10 @@ export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
         [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

@@ -50,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) &&
@@ -72,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) {
@@ -118,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);
@@ -150,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`;
@@ -163,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';
@@ -186,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) {
@@ -200,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);
@@ -220,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 });
             }
         });
@@ -230,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 });
             }
         });
@@ -244,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 });
             }
         });
@@ -443,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/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/lock-file/npm-parser.js

@@ -289,15 +289,16 @@ function getPackageParent(path, packages) {
 function mapSnapshots(rootLockFile, graph) {
     const nestedNodes = new Set();
     const visitedNodes = new Map();
-    const visitedPaths = new Set();
     const remappedPackages = new Map();
     // add first level children
     Object.values(graph.externalNodes).forEach((node) => {
         if (node.name === `npm:${node.data.packageName}`) {
             const mappedPackage = mapPackage(rootLockFile, node.data.packageName, node.data.version);
             remappedPackages.set(mappedPackage.path, mappedPackage);
-            visitedNodes.set(node, new Set([mappedPackage.path]));
-            visitedPaths.add(mappedPackage.path);
+            visitedNodes.set(node, {
+                packagePaths: new Set([mappedPackage.path]),
+                unresolvedParents: new Set(),
+            });
         }
         else {
             nestedNodes.add(node);
@@ -306,7 +307,7 @@ function mapSnapshots(rootLockFile, graph) {
     let remappedPackagesArray;
     if (nestedNodes.size) {
         const invertedGraph = (0, operators_1.reverse)(graph);
-        nestMappedPackages(invertedGraph, remappedPackages, nestedNodes, visitedNodes, visitedPaths, rootLockFile);
+        nestMappedPackages(invertedGraph, remappedPackages, nestedNodes, visitedNodes, rootLockFile);
         // initially we naively map package paths to topParent/../parent/child
         // but some of those should be nested higher up the tree
         remappedPackagesArray = elevateNestedPaths(remappedPackages);
@@ -332,31 +333,34 @@ function mapPackage(rootLockFile, packageName, version, parentPath = '') {
         valueV3,
     };
 }
-function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, visitedPaths, rootLockFile) {
+function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, rootLockFile) {
     const initialSize = nestedNodes.size;
     if (!initialSize) {
         return;
     }
     nestedNodes.forEach((node) => {
-        let unresolvedParents = invertedGraph.dependencies[node.name].length;
+        if (!visitedNodes.has(node)) {
+            visitedNodes.set(node, {
+                packagePaths: new Set(),
+                unresolvedParents: new Set(invertedGraph.dependencies[node.name].map(({ target }) => target)),
+            });
+        }
         invertedGraph.dependencies[node.name].forEach(({ target }) => {
+            if (!visitedNodes.get(node).unresolvedParents.has(target)) {
+                return;
+            }
             const targetNode = invertedGraph.externalNodes[target];
-            if (visitedNodes.has(targetNode)) {
-                visitedNodes.get(targetNode).forEach((path) => {
+            if (visitedNodes.has(targetNode) &&
+                !visitedNodes.get(targetNode).unresolvedParents.size) {
+                visitedNodes.get(targetNode).packagePaths.forEach((path) => {
                     const mappedPackage = mapPackage(rootLockFile, node.data.packageName, node.data.version, path + '/');
                     result.set(mappedPackage.path, mappedPackage);
-                    if (visitedNodes.has(node)) {
-                        visitedNodes.get(node).add(mappedPackage.path);
-                    }
-                    else {
-                        visitedNodes.set(node, new Set([mappedPackage.path]));
-                    }
-                    visitedPaths.add(mappedPackage.path);
+                    visitedNodes.get(node).packagePaths.add(mappedPackage.path);
+                    visitedNodes.get(node).unresolvedParents.delete(target);
                 });
-                unresolvedParents--;
             }
         });
-        if (!unresolvedParents) {
+        if (!visitedNodes.get(node).unresolvedParents.size) {
             nestedNodes.delete(node);
         }
     });
@@ -367,7 +371,7 @@ function nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, vi
         ].join('\n'));
     }
     else {
-        nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, visitedPaths, rootLockFile);
+        nestMappedPackages(invertedGraph, result, nestedNodes, visitedNodes, rootLockFile);
     }
 }
 // sort paths by number of segments and then alphabetically

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

@@ -246,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/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/utils/package-json.d.ts

@@ -1,6 +1,7 @@
 import { InputDefinition, ProjectMetadata, TargetConfiguration } from '../config/workspace-json-project-json';
 import { PackageManagerCommands } from './package-manager';
 export interface NxProjectPackageJsonConfiguration {
+    name?: string;
     implicitDependencies?: string[];
     tags?: string[];
     namedInputs?: {