nx 18.3.0-canary.20240405-fc8d5ba → 18.3.0-canary.20240409-32144bb

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.3.0-canary.20240405-fc8d5ba",
+  "version": "18.3.0-canary.20240409-32144bb",
   "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": "18.3.0-canary.20240405-fc8d5ba"
+    "@nrwl/tao": "18.3.0-canary.20240409-32144bb"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-darwin-arm64": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-linux-x64-gnu": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-linux-x64-musl": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-win32-x64-msvc": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-linux-arm64-gnu": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-linux-arm64-musl": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-linux-arm-gnueabihf": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-win32-arm64-msvc": "18.3.0-canary.20240405-fc8d5ba",
-    "@nx/nx-freebsd-x64": "18.3.0-canary.20240405-fc8d5ba"
+    "@nx/nx-darwin-x64": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-darwin-arm64": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-linux-x64-gnu": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-linux-x64-musl": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-win32-x64-msvc": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-linux-arm64-gnu": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-linux-arm64-musl": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-linux-arm-gnueabihf": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-win32-arm64-msvc": "18.3.0-canary.20240409-32144bb",
+    "@nx/nx-freebsd-x64": "18.3.0-canary.20240409-32144bb"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/init/implementation/react/index.js

@@ -100,7 +100,7 @@ async function reorgnizeWorkspaceStructure(options) {
         ? `npx nx build ${options.reactAppName}`
         : 'npm run build';
     (0, utils_1.printFinalMessage)({
-        learnMoreLink: 'https://nx.dev/recipes/react/migration-cra',
+        learnMoreLink: 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project',
         bodyLines: [
             `- Execute "${buildCommand}" twice to see the computation caching in action.`,
         ],

package/src/command-line/report/report.d.ts

@@ -1,5 +1,6 @@
 import { PackageManager } from '../../utils/package-manager';
 import { PackageJson } from '../../utils/package-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
 export declare const packagesWeCareAbout: string[];
 export declare const patternsWeIgnoreInCommunityReport: Array<string | RegExp>;
 /**
@@ -16,6 +17,7 @@ export interface ReportData {
     pmVersion: string;
     localPlugins: string[];
     communityPlugins: PackageJson[];
+    registeredPlugins: string[];
     packageVersionsWeCareAbout: {
         package: string;
         version: string;
@@ -41,6 +43,7 @@ interface OutOfSyncPackageGroup {
 }
 export declare function findMisalignedPackagesForPackage(base: PackageJson): undefined | OutOfSyncPackageGroup;
 export declare function findInstalledCommunityPlugins(): PackageJson[];
+export declare function findRegisteredPluginsBeingUsed(nxJson: NxJsonConfiguration): string[];
 export declare function findInstalledPackagesWeCareAbout(): {
     package: string;
     version: string;

package/src/command-line/report/report.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findInstalledPackagesWeCareAbout = exports.findInstalledCommunityPlugins = exports.findMisalignedPackagesForPackage = exports.getReportData = exports.reportHandler = exports.patternsWeIgnoreInCommunityReport = exports.packagesWeCareAbout = void 0;
+exports.findInstalledPackagesWeCareAbout = exports.findRegisteredPluginsBeingUsed = exports.findInstalledCommunityPlugins = exports.findMisalignedPackagesForPackage = exports.getReportData = exports.reportHandler = exports.patternsWeIgnoreInCommunityReport = exports.packagesWeCareAbout = void 0;
 const chalk = require("chalk");
 const output_1 = require("../../utils/output");
 const path_1 = require("path");
@@ -36,7 +36,7 @@ const LINE_SEPARATOR = '---------------------------------------';
  *
  */
 async function reportHandler() {
-    const { pm, pmVersion, localPlugins, communityPlugins, packageVersionsWeCareAbout, outOfSyncPackageGroup, projectGraphError, } = await getReportData();
+    const { pm, pmVersion, localPlugins, communityPlugins, registeredPlugins, packageVersionsWeCareAbout, outOfSyncPackageGroup, projectGraphError, } = await getReportData();
     const bodyLines = [
         `Node   : ${process.versions.node}`,
         `OS     : ${process.platform}-${process.arch}`,
@@ -47,6 +47,13 @@ async function reportHandler() {
     packageVersionsWeCareAbout.forEach((p) => {
         bodyLines.push(`${chalk.green(p.package.padEnd(padding))} : ${chalk.bold(p.version)}`);
     });
+    if (registeredPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('Registered Plugins:');
+        for (const plugin of registeredPlugins) {
+            bodyLines.push(`${chalk.green(plugin)}`);
+        }
+    }
     if (communityPlugins.length) {
         bodyLines.push(LINE_SEPARATOR);
         padding = Math.max(...communityPlugins.map((x) => x.name.length)) + 1;
@@ -86,8 +93,10 @@ exports.reportHandler = reportHandler;
 async function getReportData() {
     const pm = (0, package_manager_1.detectPackageManager)();
     const pmVersion = (0, package_manager_1.getPackageManagerVersion)(pm);
-    const localPlugins = await findLocalPlugins((0, nx_json_1.readNxJson)());
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const localPlugins = await findLocalPlugins(nxJson);
     const communityPlugins = findInstalledCommunityPlugins();
+    const registeredPlugins = findRegisteredPluginsBeingUsed(nxJson);
     let projectGraphError = null;
     if (isNativeAvailable()) {
         try {
@@ -114,6 +123,7 @@ async function getReportData() {
         pmVersion,
         localPlugins,
         communityPlugins,
+        registeredPlugins,
         packageVersionsWeCareAbout,
         outOfSyncPackageGroup,
         projectGraphError,
@@ -178,6 +188,13 @@ function findInstalledCommunityPlugins() {
             : pattern.test(dep.name)));
 }
 exports.findInstalledCommunityPlugins = findInstalledCommunityPlugins;
+function findRegisteredPluginsBeingUsed(nxJson) {
+    if (!nxJson.plugins) {
+        return [];
+    }
+    return nxJson.plugins.map((plugin) => typeof plugin === 'object' ? plugin.plugin : plugin);
+}
+exports.findRegisteredPluginsBeingUsed = findRegisteredPluginsBeingUsed;
 function findInstalledPackagesWeCareAbout() {
     const packagesWeMayCareAbout = {};
     // TODO (v19): Remove workaround for hiding @nrwl packages when matching @nx package is found.

package/src/config/workspace-json-project-json.d.ts

@@ -99,10 +99,18 @@ export interface ProjectConfiguration {
     release?: {
         version?: Pick<NxReleaseVersionConfiguration, 'generator' | 'generatorOptions'>;
     };
-    metadata?: {
-        technologies?: string[];
-        targetGroups?: Record<string, string[]>;
-    };
+    /**
+     * Metadata about the project
+     */
+    metadata?: ProjectMetadata;
+}
+export interface ProjectMetadata {
+    technologies?: string[];
+    targetGroups?: Record<string, string[]>;
+}
+export interface TargetMetadata {
+    description?: string;
+    technologies?: string[];
 }
 export interface TargetDependencyConfig {
     /**
@@ -190,4 +198,8 @@ export interface TargetConfiguration<T = any> {
      * Determines if Nx is able to cache a given target.
      */
     cache?: boolean;
+    /**
+     * Metadata about the target
+     */
+    metadata?: TargetMetadata;
 }

package/src/daemon/server/project-graph-incremental-recomputation.js

@@ -162,7 +162,7 @@ async function processFilesAndCreateAndSerializeProjectGraph() {
         const errors = [...(projectConfigurationsError?.errors ?? [])];
         if (g.error) {
             if (g.error instanceof build_project_graph_1.CreateDependenciesError) {
-                errors.concat(g.error.errors);
+                errors.push(...g.error.errors);
             }
             else {
                 return {

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

@@ -39,10 +39,13 @@ export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
     parsedArgs: {
         [k: string]: any;
     };
+    unparsedCommandArgs?: {
+        [k: string]: string;
+    };
     args?: string;
 }
 export default function (options: RunCommandsOptions, context: ExecutorContext): Promise<{
     success: boolean;
     terminalOutput: string;
 }>;
-export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions'>, forwardAllArgs: boolean): string;
+export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;

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

@@ -129,6 +129,7 @@ function normalizeOptions(options) {
         .filter((p) => propKeys.indexOf(p) === -1 && unparsedCommandArgs[p] === undefined)
         .reduce((m, c) => ((m[c] = options[c]), m), {});
     options.parsedArgs = parseArgs(unparsedCommandArgs, options.unknownOptions, options.args);
+    options.unparsedCommandArgs = unparsedCommandArgs;
     options.commands.forEach((c) => {
         c.command = interpolateArgsIntoCommand(c.command, options, c.forwardAllArgs ?? true);
     });
@@ -162,12 +163,15 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
         !commandConfig.prefix &&
         !isParallel &&
         usePty) {
+        let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+        if (streamOutput) {
+            process.stdout.write(terminalOutput);
+        }
         const cp = pseudoTerminal.runCommand(commandConfig.command, {
             cwd,
             jsEnv: env,
             quiet: !streamOutput,
         });
-        let terminalOutput = '';
         return new Promise((res) => {
             cp.onOutput((output) => {
                 terminalOutput += output;
@@ -188,7 +192,10 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
     return nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput);
 }
 function nodeProcess(commandConfig, cwd, env, readyWhen, streamOutput = true) {
-    let terminalOutput = '';
+    let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+    if (streamOutput) {
+        process.stdout.write(terminalOutput);
+    }
     return new Promise((res) => {
         const childProcess = (0, child_process_1.exec)(commandConfig.command, {
             maxBuffer: exports.LARGE_BUFFER,
@@ -297,7 +304,10 @@ function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
             args += ` ${opts.args}`;
         }
         if (opts.__unparsed__?.length > 0) {
-            args += ` ${opts.__unparsed__.join(' ')}`;
+            const filterdParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.unparsedCommandArgs);
+            if (filterdParsedOptions.length > 0) {
+                args += ` ${filterdParsedOptions.join(' ')}`;
+            }
         }
         return `${command}${args}`;
     }
@@ -314,3 +324,40 @@ function parseArgs(unparsedCommandArgs, unknownOptions, args) {
         configuration: { 'camel-case-expansion': false },
     });
 }
+/**
+ * This function filters out the prop keys from the unparsed options
+ * @param __unparsed__ e.g. ['--prop1', 'value1', '--prop2=value2', '--args=test']
+ * @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 = {}) {
+    const parsedOptions = [];
+    for (let index = 0; index < __unparsed__.length; index++) {
+        const element = __unparsed__[index];
+        if (element.startsWith('--')) {
+            const key = element.replace('--', '');
+            if (element.includes('=')) {
+                if (!propKeys.includes(key.split('=')[0].split('.')[0])) {
+                    // check if the key is part of the propKeys array
+                    parsedOptions.push(element);
+                }
+            }
+            else {
+                // 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]) {
+                        index++; // skip the next element
+                    }
+                }
+                else {
+                    parsedOptions.push(element);
+                }
+            }
+        }
+        else {
+            parsedOptions.push(element);
+        }
+    }
+    return parsedOptions;
+}

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

@@ -104,6 +104,9 @@ skipCommandNormalization) {
             }
         }
     }
+    if (project.metadata) {
+        updatedProjectConfiguration.metadata = mergeMetadata(sourceMap, sourceInformation, 'metadata', project.metadata, matchingProject.metadata);
+    }
     if (project.targets) {
         // We merge the targets with special handling, so clear this back to the
         // targets as defined originally before merging.
@@ -134,68 +137,69 @@ skipCommandNormalization) {
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
-    if (project.metadata) {
-        if (sourceMap) {
-            sourceMap['targets'] ??= sourceInformation;
-        }
-        for (const [metadataKey, value] of Object.entries({
-            ...project.metadata,
-        })) {
-            const existingValue = matchingProject.metadata?.[metadataKey];
-            if (Array.isArray(value) && Array.isArray(existingValue)) {
-                for (const item of [...value]) {
-                    const newLength = updatedProjectConfiguration.metadata[metadataKey].push(item);
-                    if (sourceMap) {
-                        sourceMap[`metadata.${metadataKey}.${newLength - 1}`] =
-                            sourceInformation;
-                    }
+    projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
+}
+exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
+function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata, matchingMetadata) {
+    const result = {
+        ...(matchingMetadata ?? {}),
+    };
+    for (const [metadataKey, value] of Object.entries(metadata)) {
+        const existingValue = matchingMetadata?.[metadataKey];
+        if (Array.isArray(value) && Array.isArray(existingValue)) {
+            for (const item of [...value]) {
+                const newLength = result[metadataKey].push(item);
+                if (sourceMap) {
+                    sourceMap[`${baseSourceMapPath}.${metadataKey}.${newLength - 1}`] =
+                        sourceInformation;
                 }
             }
-            else if (Array.isArray(value) && existingValue === undefined) {
-                updatedProjectConfiguration.metadata ??= {};
-                updatedProjectConfiguration.metadata[metadataKey] ??= value;
+        }
+        else if (Array.isArray(value) && existingValue === undefined) {
+            result[metadataKey] ??= value;
+            if (sourceMap) {
+                sourceMap[`${baseSourceMapPath}.${metadataKey}`] = sourceInformation;
+            }
+            for (let i = 0; i < value.length; i++) {
                 if (sourceMap) {
-                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
-                }
-                for (let i = 0; i < value.length; i++) {
-                    if (sourceMap) {
-                        sourceMap[`metadata.${metadataKey}.${i}`] = sourceInformation;
-                    }
+                    sourceMap[`${baseSourceMapPath}.${metadataKey}.${i}`] =
+                        sourceInformation;
                 }
             }
-            else if (typeof value === 'object' &&
-                typeof existingValue === 'object') {
-                for (const key in value) {
-                    const existingValue = matchingProject.metadata?.[metadataKey]?.[key];
-                    if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
-                        for (const item of value[key]) {
-                            const i = updatedProjectConfiguration.metadata[metadataKey][key].push(item);
-                            if (sourceMap) {
-                                sourceMap[`metadata.${metadataKey}.${key}.${i - 1}`] =
-                                    sourceInformation;
-                            }
-                        }
-                    }
-                    else {
-                        updatedProjectConfiguration.metadata[metadataKey] = value;
+        }
+        else if (typeof value === 'object' && typeof existingValue === 'object') {
+            for (const key in value) {
+                const existingValue = matchingMetadata?.[metadataKey]?.[key];
+                if (Array.isArray(value[key]) && Array.isArray(existingValue)) {
+                    for (const item of value[key]) {
+                        const i = result[metadataKey][key].push(item);
                         if (sourceMap) {
-                            sourceMap[`metadata.${metadataKey}`] = sourceInformation;
+                            sourceMap[`${baseSourceMapPath}.${metadataKey}.${key}.${i - 1}`] =
+                                sourceInformation;
                         }
                     }
                 }
+                else {
+                    result[metadataKey] = value;
+                    if (sourceMap) {
+                        sourceMap[`${baseSourceMapPath}.${metadataKey}`] =
+                            sourceInformation;
+                    }
+                }
             }
-            else {
-                updatedProjectConfiguration.metadata[metadataKey] = value;
-                if (sourceMap) {
-                    sourceMap[`metadata.${metadataKey}`] = sourceInformation;
-                    if (typeof value === 'object') {
-                        for (const k in value) {
-                            sourceMap[`metadata.${metadataKey}.${k}`] = sourceInformation;
-                            if (Array.isArray(value[k])) {
-                                for (let i = 0; i < value[k].length; i++) {
-                                    sourceMap[`metadata.${metadataKey}.${k}.${i}`] =
-                                        sourceInformation;
-                                }
+        }
+        else {
+            result[metadataKey] = value;
+            if (sourceMap) {
+                sourceMap[`${baseSourceMapPath}.${metadataKey}`] = sourceInformation;
+                if (typeof value === 'object') {
+                    for (const k in value) {
+                        sourceMap[`${baseSourceMapPath}.${metadataKey}.${k}`] =
+                            sourceInformation;
+                        if (Array.isArray(value[k])) {
+                            for (let i = 0; i < value[k].length; i++) {
+                                sourceMap[`${baseSourceMapPath}.${metadataKey}.${k}.${i}`] =
+                                    sourceInformation;
                             }
                         }
                     }
@@ -203,9 +207,8 @@ skipCommandNormalization) {
             }
         }
     }
-    projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
+    return result;
 }
-exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
@@ -481,6 +484,9 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     if (target.configurations || defaultConfigurations) {
         result.configurations = mergeConfigurations(target.configurations, isCompatible ? defaultConfigurations : undefined, projectConfigSourceMap, sourceInformation, targetIdentifier);
     }
+    if (target.metadata) {
+        result.metadata = mergeMetadata(projectConfigSourceMap, sourceInformation, `${targetIdentifier}.metadata`, target.metadata, baseTarget?.metadata);
+    }
     return result;
 }
 exports.mergeTargetConfigurations = mergeTargetConfigurations;

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../../utils/nx-plugin';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.