nx 17.3.1 → 17.3.2

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

@@ -4,23 +4,26 @@ const path = require("path");
 const native_1 = require("../../native");
 const child_process_1 = require("../../utils/child-process");
 const package_manager_1 = require("../../utils/package-manager");
+const child_process_2 = require("child_process");
 async function default_1(options, context) {
     const pm = (0, package_manager_1.getPackageManagerCommand)();
     try {
-        await new Promise((res, rej) => {
-            const cp = new child_process_1.PseudoTtyProcess((0, native_1.runCommand)(pm.run(options.script, options.__unparsed__.join(' ')), path.join(context.root, context.projectsConfigurations.projects[context.projectName].root), process.env));
-            cp.onExit((code) => {
-                if (code === 0) {
-                    res();
-                }
-                else if (code >= 128) {
-                    process.exit(code);
-                }
-                else {
-                    rej();
-                }
-            });
-        });
+        let command = pm.run(options.script, options.__unparsed__.join(' '));
+        let cwd = path.join(context.root, context.projectsConfigurations.projects[context.projectName].root);
+        let env = process.env;
+        // when running nx through npx with node_modules installed with npm, the path gets modified to include the full workspace path with the node_modules folder
+        // This causes issues when running in a pty process, so we filter out the node_modules paths from the PATH
+        // Since the command here will be run with the package manager script command, the path will be modified again within the PTY process itself.
+        let filteredPath = env.PATH?.split(path.delimiter)
+            .filter((p) => !p.startsWith(path.join(context.root, 'node_modules')))
+            .join(path.delimiter) ?? '';
+        env.PATH = filteredPath;
+        if (process.stdout.isTTY) {
+            await ptyProcess(command, cwd, env);
+        }
+        else {
+            nodeProcess(command, cwd, env);
+        }
         return { success: true };
     }
     catch (e) {
@@ -28,3 +31,26 @@ async function default_1(options, context) {
     }
 }
 exports.default = default_1;
+function nodeProcess(command, cwd, env) {
+    (0, child_process_2.execSync)(command, {
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd,
+        env,
+    });
+}
+async function ptyProcess(command, cwd, env) {
+    return new Promise((res, rej) => {
+        const cp = new child_process_1.PseudoTtyProcess((0, native_1.runCommand)(command, cwd, env));
+        cp.onExit((code) => {
+            if (code === 0) {
+                res();
+            }
+            else if (code >= 128) {
+                process.exit(code);
+            }
+            else {
+                rej();
+            }
+        });
+    });
+}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.createNodeFromPackageJson = exports.getNxPackageJsonWorkspacesPlugin = void 0;
+const minimatch_1 = require("minimatch");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const nx_json_1 = require("../../config/nx-json");
@@ -13,11 +14,31 @@ const package_json_1 = require("../../utils/package-json");
 const path_1 = require("../../utils/path");
 function getNxPackageJsonWorkspacesPlugin(root) {
     const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, f));
+    const patterns = getGlobPatternsFromPackageManagerWorkspaces(root, readJson);
+    // If the user only specified a negative pattern, we should find all package.json
+    // files and only return those that don't match a negative pattern.
+    const negativePatterns = patterns.filter((p) => p.startsWith('!'));
+    let positivePatterns = patterns.filter((p) => !p.startsWith('!'));
+    if (
+    // There are some negative patterns
+    negativePatterns.length > 0 &&
+        // No positive patterns
+        (positivePatterns.length === 0 ||
+            // Or only a single positive pattern that is the default coming from root package
+            (positivePatterns.length === 1 && positivePatterns[0] === 'package.json'))) {
+        positivePatterns.push('**/package.json');
+    }
     return {
         name: 'nx/core/package-json-workspaces',
         createNodes: [
-            (0, globs_1.combineGlobPatterns)(getGlobPatternsFromPackageManagerWorkspaces(root, readJson)),
-            (p) => createNodeFromPackageJson(p, root),
+            (0, globs_1.combineGlobPatterns)(positivePatterns),
+            (p) => {
+                if (!negativePatterns.some((negative) => (0, minimatch_1.minimatch)(p, negative))) {
+                    return createNodeFromPackageJson(p, root);
+                }
+                // A negative pattern matched, so we should not create a node for this package.json
+                return {};
+            },
         ],
     };
 }

package/src/plugins/target-defaults/target-defaults-plugin.js

@@ -46,22 +46,30 @@ exports.TargetDefaultsPlugin = {
                     return true;
                 }),
                 ...Object.keys(projectJson?.targets ?? {}),
+                ...Object.keys(packageJson?.nx?.targets ?? {}),
             ]);
             const executorToTargetMap = getExecutorToTargetMap(packageJson, projectJson);
-            const newTargets = {};
+            const modifiedTargets = {};
             for (const defaultSpecifier in targetDefaults) {
-                const targetName = executorToTargetMap.get(defaultSpecifier) ?? defaultSpecifier;
-                newTargets[targetName] = structuredClone(targetDefaults[defaultSpecifier]);
-                // TODO: Remove this after we figure out a way to define new targets
-                // in target defaults
-                if (!projectDefinedTargets.has(targetName)) {
-                    newTargets[targetName][exports.ONLY_MODIFIES_EXISTING_TARGET] = true;
+                const targetNames = executorToTargetMap.get(defaultSpecifier) ?? new Set();
+                targetNames.add(defaultSpecifier);
+                for (const targetName of targetNames) {
+                    // Prevents `build` from overwriting `@nx/js:tsc` if both are present
+                    // and build is specified later in the ordering.
+                    if (!modifiedTargets[targetName] || targetName !== defaultSpecifier) {
+                        modifiedTargets[targetName] = JSON.parse(JSON.stringify(targetDefaults[defaultSpecifier]));
+                    }
+                    // TODO: Remove this after we figure out a way to define new targets
+                    // in target defaults
+                    if (!projectDefinedTargets.has(targetName)) {
+                        modifiedTargets[targetName][exports.ONLY_MODIFIES_EXISTING_TARGET] = true;
+                    }
                 }
             }
             return {
                 projects: {
                     [root]: {
-                        targets: newTargets,
+                        targets: modifiedTargets,
                     },
                 },
             };
@@ -70,20 +78,18 @@ exports.TargetDefaultsPlugin = {
 };
 function getExecutorToTargetMap(packageJson, projectJson) {
     const executorToTargetMap = new Map();
-    if (packageJson?.scripts) {
-        for (const script in packageJson.scripts) {
-            executorToTargetMap.set('nx:run-script', script);
-        }
-    }
-    if (projectJson?.targets) {
-        for (const target in projectJson.targets) {
-            if (projectJson.targets[target].executor) {
-                executorToTargetMap.set(projectJson.targets[target].executor, target);
-            }
-            else if (projectJson.targets[target].command) {
-                executorToTargetMap.set('nx:run-commands', target);
-            }
-        }
+    const targets = Object.keys({
+        ...projectJson?.targets,
+        ...packageJson?.scripts,
+        ...packageJson?.nx?.targets,
+    });
+    for (const target of targets) {
+        const executor = projectJson?.targets?.[target]?.executor ??
+            packageJson?.nx?.targets?.[target]?.executor ??
+            'nx:run-script';
+        const targetsForExecutor = executorToTargetMap.get(executor) ?? new Set();
+        targetsForExecutor.add(target);
+        executorToTargetMap.set(executor, targetsForExecutor);
     }
     return executorToTargetMap;
 }

package/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.js

@@ -132,8 +132,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
     };
     lifeCycle.printTaskTerminalOutput = (task, cacheStatus, terminalOutput) => {
         if (task.target.project === initiatingProject) {
-            output_1.output.logCommand(task.id, cacheStatus);
-            process.stdout.write(terminalOutput);
+            output_1.output.logCommandOutput(task.id, cacheStatus, terminalOutput);
         }
         else {
             tasksToTerminalOutputs[task.id] = terminalOutput;
@@ -162,8 +161,7 @@ async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, arg
                         clearRenderInterval();
                         renderDependentTargets(false);
                         output_1.output.addVerticalSeparator('red');
-                        output_1.output.logCommand(t.task.id, t.status);
-                        process.stdout.write(tasksToTerminalOutputs[t.task.id]);
+                        output_1.output.logCommandOutput(t.task.id, t.status, tasksToTerminalOutputs[t.task.id]);
                     }
                     break;
             }

package/src/tasks-runner/life-cycles/empty-terminal-output-life-cycle.js

@@ -9,8 +9,7 @@ class EmptyTerminalOutputLifeCycle {
             cacheStatus === 'failure' ||
             cacheStatus === 'skipped') {
             const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-            output_1.output.logCommand(args.join(' '), cacheStatus);
-            process.stdout.write(terminalOutput);
+            output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
         }
     }
 }

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -61,8 +61,7 @@ class InvokeRunnerTerminalOutputLifeCycle {
     }
     printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        output_1.output.logCommand(args.join(' '), cacheStatus);
-        process.stdout.write(terminalOutput);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
     }
 }
 exports.InvokeRunnerTerminalOutputLifeCycle = InvokeRunnerTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -93,8 +93,7 @@ class StaticRunManyTerminalOutputLifeCycle {
     }
     printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-        output_1.output.logCommand(args.join(' '), cacheStatus);
-        process.stdout.write(terminalOutput);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
     }
 }
 exports.StaticRunManyTerminalOutputLifeCycle = StaticRunManyTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.js

@@ -82,8 +82,7 @@ class StaticRunOneTerminalOutputLifeCycle {
             status === 'failure' ||
             task.target.project === this.initiatingProject) {
             const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-            output_1.output.logCommand(args.join(' '), status);
-            process.stdout.write(terminalOutput);
+            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
         }
     }
 }

package/src/utils/output.d.ts

@@ -58,6 +58,9 @@ declare class CLIOutput {
     success({ title, bodyLines }: CLISuccessMessageConfig): void;
     logSingleLine(message: string): void;
     logCommand(message: string, taskStatus?: TaskStatus): void;
+    logCommandOutput(message: string, taskStatus: TaskStatus, output: string): void;
+    private getCommandWithStatus;
+    private getStatusIcon;
     private normalizeMessage;
     private addTaskStatus;
     log({ title, bodyLines, color }: CLIWarnMessageConfig & {

package/src/utils/output.js

@@ -5,6 +5,8 @@ const chalk = require("chalk");
 const os_1 = require("os");
 const readline = require("readline");
 const is_ci_1 = require("./is-ci");
+const GH_GROUP_PREFIX = '::group::';
+const GH_GROUP_SUFFIX = '::endgroup::';
 /**
  * Automatically disable styling applied by chalk if CI=true
  */
@@ -152,11 +154,42 @@ class CLIOutput {
     }
     logCommand(message, taskStatus) {
         this.addNewline();
-        const commandOutput = chalk.dim('> ') + this.formatCommand(this.normalizeMessage(message));
-        const commandOutputWithStatus = this.addTaskStatus(taskStatus, commandOutput);
+        this.writeToStdOut(this.getCommandWithStatus(message, taskStatus));
+        this.addNewline();
+        this.addNewline();
+    }
+    logCommandOutput(message, taskStatus, output) {
+        let commandOutputWithStatus = this.getCommandWithStatus(message, taskStatus);
+        if (process.env.GITHUB_ACTIONS) {
+            const icon = this.getStatusIcon(taskStatus);
+            commandOutputWithStatus = `${GH_GROUP_PREFIX}${icon} ${commandOutputWithStatus}`;
+        }
+        this.addNewline();
         this.writeToStdOut(commandOutputWithStatus);
         this.addNewline();
         this.addNewline();
+        this.writeToStdOut(output);
+        if (process.env.GITHUB_ACTIONS) {
+            this.writeToStdOut(GH_GROUP_SUFFIX);
+        }
+    }
+    getCommandWithStatus(message, taskStatus) {
+        const commandOutput = chalk.dim('> ') + this.formatCommand(this.normalizeMessage(message));
+        return this.addTaskStatus(taskStatus, commandOutput);
+    }
+    getStatusIcon(taskStatus) {
+        switch (taskStatus) {
+            case 'success':
+                return '✔️';
+            case 'failure':
+                return '❌';
+            case 'skipped':
+            case 'local-cache-kept-existing':
+                return '⏩';
+            case 'local-cache':
+            case 'remote-cache':
+                return '🔁';
+        }
     }
     normalizeMessage(message) {
         if (message.startsWith('nx run ')) {

package/src/utils/package-json.d.ts

@@ -1,12 +1,11 @@
 import { InputDefinition, TargetConfiguration } from '../config/workspace-json-project-json';
-export type PackageJsonTargetConfiguration = Omit<TargetConfiguration, 'executor'>;
 export interface NxProjectPackageJsonConfiguration {
     implicitDependencies?: string[];
     tags?: string[];
     namedInputs?: {
         [inputName: string]: (string | InputDefinition)[];
     };
-    targets?: Record<string, PackageJsonTargetConfiguration>;
+    targets?: Record<string, TargetConfiguration>;
     includedScripts?: string[];
 }
 export type ArrayPackageGroup = {