nx 18.2.3 → 18.3.0-beta.0

package/bin/init-local.js

@@ -126,7 +126,7 @@ function handleAngularCLIFallbacks(workspace) {
         if (!process.argv[3]) {
             console.log(`"ng completion" is not natively supported by Nx.
   Instead, you could try an Nx Editor Plugin for a visual tool to run Nx commands. If you're using VSCode, you can use the Nx Console plugin, or if you're using WebStorm, you could use one of the available community plugins.
-  For more information, see https://nx.dev/features/integrate-with-editors`);
+  For more information, see https://nx.dev/getting-started/editor-setup`);
         }
     }
     else if (process.argv[2] === 'cache') {

package/package.json

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

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.push(...g.error.errors);
+                errors.concat(g.error.errors);
             }
             else {
                 return {

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

@@ -39,13 +39,10 @@ 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' | 'unparsedCommandArgs'>, forwardAllArgs: boolean): string;
+export declare function interpolateArgsIntoCommand(command: string, opts: Pick<NormalizedRunCommandsOptions, 'args' | 'parsedArgs' | '__unparsed__' | 'unknownOptions'>, forwardAllArgs: boolean): string;

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

@@ -129,7 +129,6 @@ 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);
     });
@@ -163,15 +162,12 @@ 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;
@@ -192,10 +188,7 @@ 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 = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
-    if (streamOutput) {
-        process.stdout.write(terminalOutput);
-    }
+    let terminalOutput = '';
     return new Promise((res) => {
         const childProcess = (0, child_process_1.exec)(commandConfig.command, {
             maxBuffer: exports.LARGE_BUFFER,
@@ -304,10 +297,7 @@ function interpolateArgsIntoCommand(command, opts, forwardAllArgs) {
             args += ` ${opts.args}`;
         }
         if (opts.__unparsed__?.length > 0) {
-            const filterdParsedOptions = filterPropKeysFromUnParsedOptions(opts.__unparsed__, opts.unparsedCommandArgs);
-            if (filterdParsedOptions.length > 0) {
-                args += ` ${filterdParsedOptions.join(' ')}`;
-            }
+            args += ` ${opts.__unparsed__.join(' ')}`;
         }
         return `${command}${args}`;
     }
@@ -324,40 +314,3 @@ 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;