nx 17.0.2 → 17.0.4

package/src/command-line/run/run-one.js

@@ -18,7 +18,7 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
     perf_hooks_1.performance.measure('code-loading', 'init-local', 'code-loading:end');
     (0, workspace_configuration_check_1.workspaceConfigurationCheck)();
     const nxJson = (0, configuration_1.readNxJson)();
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
     const opts = parseRunOneOptions(cwd, args, projectGraph, nxJson);
     const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
         ...opts.parsedArgs,
@@ -48,9 +48,6 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, opts.project, extraTargetDependencies, extraOptions);
-        // fix for https://github.com/nrwl/nx/issues/1666
-        if (process.stdin['unref'])
-            process.stdin.unref();
         process.exit(status);
     }
 }
@@ -80,7 +77,7 @@ function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
     let project;
     let target;
     let configuration;
-    if (parsedArgs['project:target:configuration'].indexOf(':') > -1) {
+    if (parsedArgs['project:target:configuration']?.indexOf(':') > -1) {
         // run case
         [project, target, configuration] = (0, split_target_1.splitTarget)(parsedArgs['project:target:configuration'], projectGraph);
         // this is to account for "nx npmsript:dev"
@@ -90,7 +87,7 @@ function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
         }
     }
     else {
-        target = parsedArgs['project:target:configuration'];
+        target = parsedArgs.target ?? parsedArgs['project:target:configuration'];
     }
     if (parsedArgs.project) {
         project = parsedArgs.project;

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

@@ -9,6 +9,8 @@ const project_graph_1 = require("../../project-graph/project-graph");
 const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("./executor-utils");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const child_process_1 = require("child_process");
 function printRunHelp(opts, schema, plugin) {
     (0, print_help_1.printHelp)(`run ${opts.project}:${opts.target}`, schema, {
         mode: 'run',
@@ -45,30 +47,53 @@ async function iteratorToProcessStatusCode(i) {
         clearInterval(keepProcessAliveInterval);
     }
 }
-async function parseExecutorAndTarget({ project, target, configuration }, root, projectsConfigurations, nxJsonConfiguration) {
+async function parseExecutorAndTarget({ project, target }, root, projectsConfigurations) {
     const proj = projectsConfigurations.projects[project];
     const targetConfig = proj.targets?.[target];
     if (!targetConfig) {
         throw new Error(`Cannot find target '${target}' for project '${project}'`);
     }
     const [nodeModule, executor] = targetConfig.executor.split(':');
-    const { schema, implementationFactory } = (0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root);
+    const { schema, implementationFactory } = (0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects);
     return { executor, implementationFactory, nodeModule, schema, targetConfig };
 }
-async function printTargetRunHelpInternal({ project, target, configuration }, root, projectsConfigurations, nxJsonConfiguration) {
-    const { executor, nodeModule, schema } = await parseExecutorAndTarget({ project, target, configuration }, root, projectsConfigurations, nxJsonConfiguration);
+async function printTargetRunHelpInternal({ project, target }, root, projectsConfigurations) {
+    const { executor, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target }, root, projectsConfigurations);
     printRunHelp({ project, target }, schema, {
         plugin: nodeModule,
         entity: executor,
     });
-    process.exit(0);
+    if (nodeModule === 'nx' &&
+        executor === 'run-commands' &&
+        targetConfig.options.command) {
+        const command = targetConfig.options.command.split(' ')[0];
+        const helpCommand = `${command} --help`;
+        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+            await new Promise(() => {
+                const cp = terminal.runCommand(helpCommand);
+                cp.onExit((code) => {
+                    process.exit(code);
+                });
+            });
+        }
+        else {
+            const cp = (0, child_process_1.exec)(helpCommand);
+            cp.on('exit', (code) => {
+                process.exit(code);
+            });
+        }
+    }
+    else {
+        process.exit(0);
+    }
 }
 async function runExecutorInternal({ project, target, configuration }, overrides, root, cwd, projectsConfigurations, nxJsonConfiguration, projectGraph, taskGraph, isVerbose) {
     validateProject(projectsConfigurations, project);
-    const { executor, implementationFactory, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target, configuration }, root, projectsConfigurations, nxJsonConfiguration);
+    const { executor, implementationFactory, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target, configuration }, root, projectsConfigurations);
     configuration ??= targetConfig.defaultConfiguration;
     const combinedOptions = (0, params_1.combineOptionsForExecutor)(overrides, configuration, targetConfig, schema, project, (0, path_1.relative)(root, cwd), isVerbose);
-    if ((0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root).isNxExecutor) {
+    if ((0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects).isNxExecutor) {
         const implementation = implementationFactory();
         const r = implementation(combinedOptions, {
             root,
@@ -101,6 +126,7 @@ async function runExecutorInternal({ project, target, configuration }, overrides
             target,
             configuration,
             runOptions: combinedOptions,
+            projects: projectsConfigurations.projects,
         }, isVerbose);
         const { eachValueFrom } = await Promise.resolve().then(() => require('../../adapter/rxjs-for-await'));
         return eachValueFrom(observable);
@@ -142,8 +168,7 @@ function printTargetRunHelp(targetDescription, root) {
     const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
     return (0, params_1.handleErrors)(false, async () => {
         const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
-        const nxJsonConfiguration = (0, configuration_1.readNxJson)();
-        printTargetRunHelpInternal(targetDescription, root, projectsConfigurations, nxJsonConfiguration);
+        await printTargetRunHelpInternal(targetDescription, root, projectsConfigurations);
     });
 }
 exports.printTargetRunHelp = printTargetRunHelp;

package/src/command-line/run-many/command-object.js

@@ -3,9 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsRunManyCommand = void 0;
 const documentation_1 = require("../yargs-utils/documentation");
 const shared_options_1 = require("../yargs-utils/shared-options");
+const params_1 = require("../../utils/params");
 exports.yargsRunManyCommand = {
     command: 'run-many',
     describe: 'Run target for multiple listed projects',
     builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs)))), 'run-many'),
-    handler: async (args) => (await Promise.resolve().then(() => require('./run-many'))).runMany((0, shared_options_1.withOverrides)(args)),
+    handler: async (args) => await (0, params_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+        (await Promise.resolve().then(() => require('./run-many'))).runMany((0, shared_options_1.withOverrides)(args));
+    }),
 };

package/src/command-line/run-many/run-many.js

@@ -40,9 +40,6 @@ async function runMany(args, extraTargetDependencies = {}, extraOptions = { excl
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
-        // fix for https://github.com/nrwl/nx/issues/1666
-        if (process.stdin['unref'])
-            process.stdin.unref();
         process.exit(status);
     }
 }

package/src/command-line/show/command-object.d.ts

@@ -14,8 +14,11 @@ export type ShowProjectsOptions = NxShowArgs & {
     type: ProjectGraphProjectNode['type'];
     projects: string[];
     withTarget: string[];
+    verbose: boolean;
 };
 export type ShowProjectOptions = NxShowArgs & {
     projectName: string;
+    web?: boolean;
+    verbose: boolean;
 };
 export declare const yargsShowCommand: CommandModule<Record<string, unknown>, NxShowArgs>;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yargsShowCommand = void 0;
 const yargs_1 = require("yargs");
 const shared_options_1 = require("../yargs-utils/shared-options");
+const params_1 = require("../../utils/params");
 exports.yargsShowCommand = {
     command: 'show',
     describe: 'Show information about the workspace (e.g., list of projects)',
@@ -46,6 +47,10 @@ const showProjectsCommand = {
         type: 'string',
         description: 'Select only projects of the given type',
         choices: ['app', 'lib', 'e2e'],
+    })
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Prints additional information about the commands (e.g., stack traces)',
     })
         .implies('untracked', 'affected')
         .implies('uncommitted', 'affected')
@@ -57,7 +62,11 @@ const showProjectsCommand = {
         .example('$0 show projects --affected', 'Show affected projects in the workspace')
         .example('$0 show projects --type app --affected', 'Show affected apps in the workspace')
         .example('$0 show projects --affected --exclude=*-e2e', 'Show affected projects in the workspace, excluding end-to-end projects'),
-    handler: (args) => Promise.resolve().then(() => require('./show')).then((m) => m.showProjectsHandler(args)),
+    handler: (args) => {
+        return (0, params_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./show'))).showProjectsHandler(args);
+        });
+    },
 };
 const showProjectCommand = {
     command: 'project <projectName>',
@@ -69,6 +78,24 @@ const showProjectCommand = {
         description: 'Which project should be viewed?',
     })
         .default('json', true)
+        .option('web', {
+        type: 'boolean',
+        description: 'Show project details in the browser',
+    })
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Prints additional information about the commands (e.g., stack traces)',
+    })
+        .check((argv) => {
+        if (argv.web) {
+            argv.json = false;
+        }
+        return true;
+    })
         .example('$0 show project my-app', 'View project information for my-app in JSON format'),
-    handler: (args) => Promise.resolve().then(() => require('./show')).then((m) => m.showProjectHandler(args)),
+    handler: (args) => {
+        return (0, params_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            return (await Promise.resolve().then(() => require('./show'))).showProjectHandler(args);
+        });
+    },
 };

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

@@ -10,6 +10,7 @@ const project_graph_1 = require("../../project-graph/project-graph");
 const all_file_data_1 = require("../../utils/all-file-data");
 const command_line_utils_1 = require("../../utils/command-line-utils");
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const graph_1 = require("../graph/graph");
 async function showProjectsHandler(args) {
     let graph = await (0, project_graph_1.createProjectGraphAsync)();
     const nxJson = (0, nx_json_1.readNxJson)();
@@ -70,6 +71,14 @@ async function showProjectHandler(args) {
     if (args.json) {
         console.log(JSON.stringify(node.data));
     }
+    else if (args.web) {
+        await (0, graph_1.generateGraph)({
+            view: 'project-details',
+            focus: node.name,
+            watch: true,
+            open: true,
+        }, []);
+    }
     else {
         const chalk = require('chalk');
         const logIfExists = (label, key) => {

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -17,6 +17,7 @@ export interface RunOptions {
     cloud: boolean;
     dte: boolean;
     batch: boolean;
+    useAgents: boolean;
 }
 export declare function withRunOptions<T>(yargs: Argv<T>): Argv<T & RunOptions>;
 export declare function withTargetAndConfigurationOption(yargs: Argv, demandOption?: boolean): Argv<{
@@ -52,7 +53,9 @@ export declare function withOverrides<T extends {
 }>(args: T, commandLevel?: number): T & {
     __overrides_unparsed__: string[];
 };
-export declare function withOutputStyleOption(yargs: Argv, choices?: string[]): Argv<{
+declare const allOutputStyles: readonly ["dynamic", "static", "stream", "stream-without-prefixes", "compact"];
+export type OutputStyle = typeof allOutputStyles[number];
+export declare function withOutputStyleOption(yargs: Argv, choices?: ReadonlyArray<OutputStyle>): Argv<{
     "output-style": string;
 }>;
 export declare function withDepGraphOptions(yargs: Argv): Argv<{

package/src/command-line/yargs-utils/shared-options.js

@@ -68,6 +68,11 @@ function withRunOptions(yargs) {
         .options('dte', {
         type: 'boolean',
         hidden: true,
+    })
+        .options('useAgents', {
+        type: 'boolean',
+        hidden: true,
+        alias: 'agents',
     });
 }
 exports.withRunOptions = withRunOptions;
@@ -174,7 +179,19 @@ function withOverrides(args, commandLevel = 1) {
     };
 }
 exports.withOverrides = withOverrides;
-function withOutputStyleOption(yargs, choices = ['dynamic', 'static', 'stream', 'stream-without-prefixes']) {
+const allOutputStyles = [
+    'dynamic',
+    'static',
+    'stream',
+    'stream-without-prefixes',
+    'compact',
+];
+function withOutputStyleOption(yargs, choices = [
+    'dynamic',
+    'static',
+    'stream',
+    'stream-without-prefixes',
+]) {
     return yargs.option('output-style', {
         describe: 'Defines how Nx emits outputs tasks logs',
         type: 'string',
@@ -234,13 +251,7 @@ function withDepGraphOptions(yargs) {
 exports.withDepGraphOptions = withDepGraphOptions;
 function withRunOneOptions(yargs) {
     const executorShouldShowHelp = !(process.argv[2] === 'run' && process.argv[3] === '--help');
-    const res = withRunOptions(withOutputStyleOption(withConfiguration(yargs), [
-        'dynamic',
-        'static',
-        'stream',
-        'stream-without-prefixes',
-        'compact',
-    ]))
+    const res = withRunOptions(withOutputStyleOption(withConfiguration(yargs), allOutputStyles))
         .parserConfiguration({
         'strip-dashed': true,
         'unknown-options-as-args': true,
@@ -267,7 +278,10 @@ function parseCSV(args) {
         return [];
     }
     if (Array.isArray(args)) {
-        return args;
+        // If parseCSV is used on `type: 'array'`, the first option may be something like ['a,b,c'].
+        return args.length === 1 && args[0].includes(',')
+            ? parseCSV(args[0])
+            : args;
     }
     const items = args.split(',');
     return items.map((i) => i.startsWith('"') && i.endsWith('"') ? i.slice(1, -1) : i);

package/src/commands-runner/command-graph.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Graph of Tasks to be executed
+ */
+export interface CommandGraph {
+    /**
+     * Projects that do not have any dependencies and are thus ready to execute immediately
+     */
+    roots: string[];
+    /**
+     * Map of projects to projects which the task depends on
+     */
+    dependencies: Record<string, string[]>;
+}

package/src/commands-runner/command-graph.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/commands-runner/create-command-graph.d.ts

@@ -0,0 +1,4 @@
+import { ProjectGraph } from '../config/project-graph';
+import { NxArgs } from '../utils/command-line-utils';
+import { CommandGraph } from './command-graph';
+export declare function createCommandGraph(projectGraph: ProjectGraph, projectNames: string[], nxArgs: NxArgs): CommandGraph;

package/src/commands-runner/create-command-graph.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommandGraph = void 0;
+const task_graph_utils_1 = require("../tasks-runner/task-graph-utils");
+const output_1 = require("../utils/output");
+function createCommandGraph(projectGraph, projectNames, nxArgs) {
+    const dependencies = {};
+    for (const projectName of projectNames) {
+        if (projectGraph.dependencies[projectName].length >= 1) {
+            dependencies[projectName] = [
+                ...new Set(projectGraph.dependencies[projectName]
+                    .map((projectDep) => projectDep.target)
+                    .filter((projectDep) => projectGraph.nodes[projectDep])).values(),
+            ];
+        }
+        else {
+            dependencies[projectName] = [];
+        }
+    }
+    const roots = Object.keys(dependencies).filter((d) => dependencies[d].length === 0);
+    const commandGraph = {
+        dependencies,
+        roots,
+    };
+    const cycle = (0, task_graph_utils_1.findCycle)(commandGraph);
+    if (cycle) {
+        if (process.env.NX_IGNORE_CYCLES === 'true' || nxArgs.nxIgnoreCycles) {
+            output_1.output.warn({
+                title: `The command graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            (0, task_graph_utils_1.makeAcyclic)(commandGraph);
+        }
+        else {
+            output_1.output.error({
+                title: `Could not execute command because the project graph has a circular dependency`,
+                bodyLines: [`${cycle.join(' --> ')}`],
+            });
+            process.exit(1);
+        }
+    }
+    return commandGraph;
+}
+exports.createCommandGraph = createCommandGraph;

package/src/commands-runner/get-command-projects.d.ts

@@ -0,0 +1,3 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxArgs } from '../utils/command-line-utils';
+export declare function getCommandProjects(projectGraph: ProjectGraph, projects: ProjectGraphProjectNode[], nxArgs: NxArgs): string[];

package/src/commands-runner/get-command-projects.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCommandProjects = void 0;
+const utils_1 = require("../tasks-runner/utils");
+const create_command_graph_1 = require("./create-command-graph");
+function getCommandProjects(projectGraph, projects, nxArgs) {
+    const commandGraph = (0, create_command_graph_1.createCommandGraph)(projectGraph, projects.map((project) => project.name), nxArgs);
+    return getSortedProjects(commandGraph);
+}
+exports.getCommandProjects = getCommandProjects;
+function getSortedProjects(commandGraph, sortedProjects = []) {
+    const roots = commandGraph.roots;
+    if (!roots.length) {
+        return sortedProjects;
+    }
+    sortedProjects.push(...roots);
+    const newGraph = (0, utils_1.removeIdsFromGraph)(commandGraph, roots, commandGraph.dependencies);
+    return getSortedProjects(newGraph, sortedProjects);
+}