nx 19.0.0-canary.20240426-ac9ad35 → 19.0.0-canary.20240427-f74aeab

package/src/daemon/client/client.d.ts

@@ -2,7 +2,6 @@
 /// <reference types="node" />
 import { ChildProcess } from 'child_process';
 import { FileData, ProjectGraph } from '../../config/project-graph';
-import { NxJsonConfiguration } from '../../config/nx-json';
 import { Hash } from '../../hasher/task-hasher';
 import { Task, TaskGraph } from '../../config/task-graph';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
@@ -13,7 +12,7 @@ export type ChangedFile = {
 };
 export declare class DaemonClient {
     private readonly nxJson;
-    constructor(nxJson: NxJsonConfiguration);
+    constructor();
     private queue;
     private socketMessenger;
     private currentMessage;

package/src/daemon/client/client.js

@@ -30,20 +30,25 @@ var DaemonStatus;
     DaemonStatus[DaemonStatus["CONNECTED"] = 2] = "CONNECTED";
 })(DaemonStatus || (DaemonStatus = {}));
 class DaemonClient {
-    constructor(nxJson) {
-        this.nxJson = nxJson;
+    constructor() {
         this._daemonStatus = DaemonStatus.DISCONNECTED;
         this._waitForDaemonReady = null;
         this._daemonReady = null;
         this._out = null;
         this._err = null;
+        try {
+            this.nxJson = (0, configuration_1.readNxJson)();
+        }
+        catch (e) {
+            this.nxJson = null;
+        }
         this.reset();
     }
     enabled() {
         if (this._enabled === undefined) {
             // TODO(v19): Add migration to move it out of existing configs and remove the ?? here.
-            const useDaemonProcessOption = this.nxJson.useDaemonProcess ??
-                this.nxJson.tasksRunnerOptions?.['default']?.options?.useDaemonProcess;
+            const useDaemonProcessOption = this.nxJson?.useDaemonProcess ??
+                this.nxJson?.tasksRunnerOptions?.['default']?.options?.useDaemonProcess;
             const env = process.env.NX_DAEMON;
             // env takes precedence
             // option=true,env=false => no daemon
@@ -329,7 +334,7 @@ class DaemonClient {
     }
 }
 exports.DaemonClient = DaemonClient;
-exports.daemonClient = new DaemonClient((0, configuration_1.readNxJson)());
+exports.daemonClient = new DaemonClient();
 function isDocker() {
     try {
         (0, fs_1.statSync)('/.dockerenv');

package/src/daemon/server/shutdown-utils.js

@@ -6,6 +6,7 @@ const logger_1 = require("./logger");
 const socket_utils_1 = require("../socket-utils");
 const cache_1 = require("../cache");
 const plugins_1 = require("./plugins");
+const error_types_1 = require("../../project-graph/error-types");
 exports.SERVER_INACTIVITY_TIMEOUT_MS = 10800000; // 10800000 ms = 3 hours
 let watcherInstance;
 function storeWatcherInstance(instance) {
@@ -69,9 +70,13 @@ function respondToClient(socket, response, description) {
 }
 exports.respondToClient = respondToClient;
 async function respondWithErrorAndExit(socket, description, error) {
+    const normalizedError = error instanceof error_types_1.DaemonProjectGraphError
+        ? error_types_1.ProjectGraphError.fromDaemonProjectGraphError(error)
+        : error;
     // print some extra stuff in the error message
-    logger_1.serverLogger.requestLog(`Responding to the client with an error.`, description, error.message);
-    console.error(error.stack);
+    logger_1.serverLogger.requestLog(`Responding to the client with an error.`, description, normalizedError.message);
+    console.error(normalizedError.stack);
+    // Respond with the original error
     await respondToClient(socket, (0, socket_utils_1.serializeResult)(error, null, null), null);
 }
 exports.respondWithErrorAndExit = respondWithErrorAndExit;

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

@@ -28,6 +28,7 @@ export interface RunCommandsOptions extends Json {
     __unparsed__: string[];
     usePty?: boolean;
     streamOutput?: boolean;
+    tty?: boolean;
 }
 export interface NormalizedRunCommandsOptions extends RunCommandsOptions {
     commands: {

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

@@ -40,6 +40,7 @@ const propKeys = [
     'streamOutput',
     'verbose',
     'forwardAllArgs',
+    'tty',
 ];
 async function default_1(options, context) {
     registerProcessListener();
@@ -67,7 +68,7 @@ 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).then((result) => ({
+    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) => ({
         result,
         command: c.command,
     })));
@@ -144,7 +145,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);
+        const result = await createProcess(pseudoTerminal, c, undefined, 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`;
@@ -157,7 +158,7 @@ async function runSerially(options, context) {
     }
     return { success: true, terminalOutput };
 }
-async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cwd, env, isParallel, usePty = true, streamOutput = true) {
+async function createProcess(pseudoTerminal, commandConfig, readyWhen, 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
@@ -174,6 +175,7 @@ async function createProcess(pseudoTerminal, commandConfig, readyWhen, color, cw
             cwd,
             jsEnv: env,
             quiet: !streamOutput,
+            tty,
         });
         childProcesses.add(cp);
         return new Promise((res) => {

package/src/executors/run-commands/schema.json

@@ -100,8 +100,15 @@
     },
     "args": {
       "oneOf": [
-        { "type": "array", "items": { "type": "string" } },
-        { "type": "string" }
+        {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        {
+          "type": "string"
+        }
       ],
       "description": "Extra arguments. You can pass them as follows: nx run project:target --args='--wait=100'. You can then use {args.wait} syntax to interpolate them in the workspace config file. See example [above](#chaining-commands-interpolating-args-and-setting-the-cwd)"
     },
@@ -140,6 +147,11 @@
       "type": "boolean",
       "description": "Whether arguments should be forwarded when interpolation is not present.",
       "default": true
+    },
+    "tty": {
+      "type": "boolean",
+      "description": "Whether commands should be run with a tty terminal",
+      "hidden": true
     }
   },
   "additionalProperties": true,

package/src/generators/testing-utils/create-tree-with-empty-workspace.js

@@ -2,11 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTreeWithEmptyV1Workspace = exports.createTreeWithEmptyWorkspace = void 0;
 const tree_1 = require("../tree");
+const workspace_root_1 = require("../../utils/workspace-root");
 /**
  * Creates a host for testing.
  */
 function createTreeWithEmptyWorkspace(opts = {}) {
     const tree = new tree_1.FsTree('/virtual', false);
+    // Our unit tests are all written as though they are at the root of a workspace
+    // However, when they are run in a subdirectory of the workspaceRoot,
+    // the relative path between workspaceRoot and the directory the tests are run
+    // is prepended to the paths created in the virtual tree.
+    // Setting this envVar to workspaceRoot prevents this behaviour
+    process.env.INIT_CWD = workspace_root_1.workspaceRoot;
     return addCommonFiles(tree, opts.layout === 'apps-libs');
 }
 exports.createTreeWithEmptyWorkspace = createTreeWithEmptyWorkspace;

package/src/native/index.d.ts

@@ -150,7 +150,7 @@ export class ChildProcess {
 }
 export class RustPseudoTerminal {
   constructor()
-  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null): ChildProcess
+  runCommand(command: string, commandDir?: string | undefined | null, jsEnv?: Record<string, string> | undefined | null, quiet?: boolean | undefined | null, tty?: boolean | undefined | null): ChildProcess
   /**
    * This allows us to run a pseudoterminal with a fake node ipc channel
    * this makes it possible to be backwards compatible with the old implementation

package/src/plugins/js/lock-file/pnpm-parser.js

@@ -33,39 +33,127 @@ function getPnpmLockfileDependencies(lockFileContent, lockFileHash, ctx) {
     return getDependencies(data, keyMap, isV6, ctx);
 }
 exports.getPnpmLockfileDependencies = getPnpmLockfileDependencies;
+function matchPropValue(record, key, originalPackageName) {
+    if (!record) {
+        return undefined;
+    }
+    const index = Object.values(record).findIndex((version) => version === key);
+    if (index > -1) {
+        return Object.keys(record)[index];
+    }
+    // check if non-aliased name is found
+    if (record[originalPackageName] &&
+        key.startsWith(`/${originalPackageName}/${record[originalPackageName]}`)) {
+        return originalPackageName;
+    }
+}
+function matchedDependencyName(importer, key, originalPackageName) {
+    return (matchPropValue(importer.dependencies, key, originalPackageName) ||
+        matchPropValue(importer.optionalDependencies, key, originalPackageName) ||
+        matchPropValue(importer.peerDependencies, key, originalPackageName));
+}
+function createHashFromSnapshot(snapshot) {
+    return (snapshot.resolution?.['integrity'] ||
+        (snapshot.resolution?.['tarball']
+            ? (0, file_hasher_1.hashArray)([snapshot.resolution['tarball']])
+            : undefined));
+}
+function isLockFileKey(depVersion) {
+    return depVersion.startsWith('/');
+}
 function getNodes(data, keyMap, isV6) {
     const nodes = new Map();
-    Object.entries(data.packages).forEach(([key, snapshot]) => {
-        findPackageNames(key, snapshot, data).forEach((packageName) => {
-            const rawVersion = findVersion(key, packageName);
-            const version = parseBaseVersion(rawVersion, isV6);
-            // we don't need to keep duplicates, we can just track the keys
-            const existingNode = nodes.get(packageName)?.get(version);
-            if (existingNode) {
-                keyMap.set(key, existingNode);
-                return;
+    const maybeAliasedPackageVersions = new Map(); // <version, alias>
+    const packageNames = new Set();
+    for (const [key, snapshot] of Object.entries(data.packages)) {
+        const originalPackageName = extractNameFromKey(key);
+        if (!originalPackageName) {
+            continue;
+        }
+        // snapshot already has a name
+        if (snapshot.name) {
+            packageNames.add({
+                key,
+                packageName: snapshot.name,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+        const rootDependencyName = matchedDependencyName(data.importers['.'], key, originalPackageName) ||
+            // only root importers have devDependencies
+            matchPropValue(data.importers['.'].devDependencies, key, originalPackageName);
+        if (rootDependencyName) {
+            packageNames.add({
+                key,
+                packageName: rootDependencyName,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+        if (!snapshot.name && !rootDependencyName) {
+            packageNames.add({
+                key,
+                packageName: originalPackageName,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+        if (snapshot.peerDependencies) {
+            for (const [depName, depVersion] of Object.entries(snapshot.peerDependencies)) {
+                if (isLockFileKey(depVersion)) {
+                    maybeAliasedPackageVersions.set(depVersion, depName);
+                }
+            }
+        }
+        if (snapshot.optionalDependencies) {
+            for (const [depName, depVersion] of Object.entries(snapshot.optionalDependencies)) {
+                if (isLockFileKey(depVersion)) {
+                    maybeAliasedPackageVersions.set(depVersion, depName);
+                }
             }
+        }
+        if (snapshot.dependencies) {
+            for (const [depName, depVersion] of Object.entries(snapshot.dependencies)) {
+                if (isLockFileKey(depVersion)) {
+                    maybeAliasedPackageVersions.set(depVersion, depName);
+                }
+            }
+        }
+        const aliasedDep = maybeAliasedPackageVersions.get(key);
+        if (aliasedDep) {
+            packageNames.add({
+                key,
+                packageName: aliasedDep,
+                hash: createHashFromSnapshot(snapshot),
+            });
+        }
+    }
+    for (const { key, packageName, hash } of packageNames) {
+        const rawVersion = findVersion(key, packageName);
+        if (!rawVersion) {
+            continue;
+        }
+        const version = parseBaseVersion(rawVersion, isV6);
+        if (!version) {
+            continue;
+        }
+        if (!nodes.has(packageName)) {
+            nodes.set(packageName, new Map());
+        }
+        if (!nodes.get(packageName).has(version)) {
             const node = {
                 type: 'npm',
                 name: version ? `npm:${packageName}@${version}` : `npm:${packageName}`,
                 data: {
                     version,
                     packageName,
-                    hash: snapshot.resolution?.['integrity'] ||
-                        (0, file_hasher_1.hashArray)(snapshot.resolution?.['tarball']
-                            ? [snapshot.resolution['tarball']]
-                            : [packageName, version]),
+                    hash: hash ?? (0, file_hasher_1.hashArray)([packageName, version]),
                 },
             };
+            nodes.get(packageName).set(version, node);
             keyMap.set(key, node);
-            if (!nodes.has(packageName)) {
-                nodes.set(packageName, new Map([[version, node]]));
-            }
-            else {
-                nodes.get(packageName).set(version, node);
-            }
-        });
-    });
+        }
+        else {
+            keyMap.set(key, nodes.get(packageName).get(version));
+        }
+    }
     const hoistedDeps = (0, pnpm_normalizer_1.loadPnpmHoistedDepsDefinition)();
     const results = {};
     for (const [packageName, versionMap] of nodes.entries()) {
@@ -228,52 +316,6 @@ function findVersion(key, packageName) {
     // for tarball package the entire key is the version spec
     return key;
 }
-function findPackageNames(key, snapshot, data) {
-    const packageNames = new Set();
-    const originalPackageName = extractNameFromKey(key);
-    const matchPropValue = (record) => {
-        if (!record) {
-            return undefined;
-        }
-        const index = Object.values(record).findIndex((version) => version === key);
-        if (index > -1) {
-            return Object.keys(record)[index];
-        }
-        // check if non aliased name is found
-        if (record[originalPackageName] &&
-            key.startsWith(`/${originalPackageName}/${record[originalPackageName]}`)) {
-            return originalPackageName;
-        }
-    };
-    const matchedDependencyName = (importer) => {
-        return (matchPropValue(importer.dependencies) ||
-            matchPropValue(importer.optionalDependencies) ||
-            matchPropValue(importer.peerDependencies));
-    };
-    // snapshot already has a name
-    if (snapshot.name) {
-        packageNames.add(snapshot.name);
-    }
-    // it'a a root dependency
-    const rootDependencyName = matchedDependencyName(data.importers['.']) ||
-        // only root importers have devDependencies
-        matchPropValue(data.importers['.'].devDependencies);
-    if (rootDependencyName) {
-        packageNames.add(rootDependencyName);
-    }
-    // find a snapshot that has a dependency that points to this snapshot
-    const snapshots = Object.values(data.packages);
-    for (let i = 0; i < snapshots.length; i++) {
-        const dependencyName = matchedDependencyName(snapshots[i]);
-        if (dependencyName) {
-            packageNames.add(dependencyName);
-        }
-    }
-    if (packageNames.size === 0) {
-        packageNames.add(originalPackageName);
-    }
-    return Array.from(packageNames);
-}
 function getVersion(key, packageName) {
     const KEY_NAME_SEPARATOR_LENGTH = 2; // leading and trailing slash
     return key.slice(packageName.length + KEY_NAME_SEPARATOR_LENGTH);

package/src/project-graph/affected/locators/workspace-projects.js

@@ -15,7 +15,9 @@ const getTouchedProjects = (touchedFiles, projectGraphNodes) => {
 };
 exports.getTouchedProjects = getTouchedProjects;
 const getImplicitlyTouchedProjects = (fileChanges, projectGraphNodes, nxJson) => {
-    const implicits = {};
+    const implicits = {
+        'nx.json': '*',
+    };
     Object.values(projectGraphNodes || {}).forEach((node) => {
         const namedInputs = {
             ...nxJson.namedInputs,

package/src/project-graph/error-types.js

@@ -5,7 +5,7 @@ exports.LoadPluginError = exports.DaemonProjectGraphError = exports.isMergeNodes
 const tslib_1 = require("tslib");
 class ProjectGraphError extends Error {
     constructor(errors, partialProjectGraph, partialSourceMaps) {
-        super(`Failed to process project graph.`);
+        super(`Failed to process project graph. Run "nx reset" to fix this. Please report the issue if you keep seeing it.`);
         _ProjectGraphError_errors.set(this, void 0);
         _ProjectGraphError_partialProjectGraph.set(this, void 0);
         _ProjectGraphError_partialSourceMaps.set(this, void 0);

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -15,6 +15,8 @@ export interface PluginWorkerLoadResult {
     type: 'load-result';
     payload: {
         name: string;
+        include?: string[];
+        exclude?: string[];
         createNodesPattern: string;
         hasCreateDependencies: boolean;
         hasProcessProjectGraph: boolean;

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -73,11 +73,13 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
         return (0, messaging_1.consumeMessage)(message, {
             'load-result': (result) => {
                 if (result.success) {
-                    const { name, createNodesPattern } = result;
+                    const { name, createNodesPattern, include, exclude } = result;
                     pluginName = name;
                     pluginNames.set(worker, pluginName);
                     onload({
                         name,
+                        include,
+                        exclude,
                         createNodes: createNodesPattern
                             ? [
                                 createNodesPattern,

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -22,6 +22,8 @@ process.on('message', async (message) => {
                     type: 'load-result',
                     payload: {
                         name: plugin.name,
+                        include: plugin.include,
+                        exclude: plugin.exclude,
                         createNodesPattern: plugin.createNodes?.[0],
                         hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
                         hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,

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

@@ -44,7 +44,6 @@ async function runCreateNodesInParallel(configFiles, plugin, options, context) {
     const errors = [];
     const results = [];
     const promises = configFiles.map(async (file) => {
-        performance.mark(`${plugin.name}:createNodes:${file} - start`);
         try {
             const value = await plugin.createNodes[1](file, options, context);
             if (value) {
@@ -62,10 +61,6 @@ async function runCreateNodesInParallel(configFiles, plugin, options, context) {
                 file,
             }));
         }
-        finally {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
-            performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-        }
     });
     await Promise.all(promises).then(() => {
         performance.mark(`${plugin.name}:createNodes - end`);

package/src/tasks-runner/pseudo-terminal.d.ts

@@ -11,10 +11,11 @@ export declare class PseudoTerminal {
     static isSupported(): boolean;
     constructor(rustPseudoTerminal: RustPseudoTerminal);
     init(): Promise<void>;
-    runCommand(command: string, { cwd, jsEnv, quiet, }?: {
+    runCommand(command: string, { cwd, jsEnv, quiet, tty, }?: {
         cwd?: string;
         jsEnv?: Record<string, string>;
         quiet?: boolean;
+        tty?: boolean;
     }): PseudoTtyProcess;
     fork(id: string, script: string, { cwd, jsEnv, quiet, }: {
         cwd?: string;

package/src/tasks-runner/pseudo-terminal.js

@@ -32,8 +32,8 @@ class PseudoTerminal {
         await this.pseudoIPC.init();
         this.initialized = true;
     }
-    runCommand(command, { cwd, jsEnv, quiet, } = {}) {
-        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet));
+    runCommand(command, { cwd, jsEnv, quiet, tty, } = {}) {
+        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet, tty));
     }
     async fork(id, script, { cwd, jsEnv, quiet, }) {
         if (!this.initialized) {

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

@@ -30,7 +30,7 @@ export interface NxArgs {
     type?: string;
     batch?: boolean;
 }
-export declare function createOverrides(__overrides_unparsed__?: string[]): any;
+export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
 export declare function splitArgsIntoNxArgsAndOverrides(args: {
     [k: string]: any;
 }, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {

package/src/utils/params.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPromptsForSchema = exports.convertSmartDefaultsIntoNamedParams = exports.warnDeprecations = exports.combineOptionsForGenerator = exports.combineOptionsForExecutor = exports.applyVerbosity = exports.setDefaults = exports.validateObject = exports.validateOptsAgainstSchema = exports.SchemaError = exports.convertAliases = exports.coerceTypesInOptions = exports.convertToCamelCase = exports.handleErrors = void 0;
 const logger_1 = require("./logger");
 const output_1 = require("./output");
+const client_1 = require("../daemon/client/client");
 const LIST_CHOICE_DISPLAY_LIMIT = 10;
 async function handleErrors(isVerbose, fn) {
     try {
@@ -41,6 +42,9 @@ async function handleErrors(isVerbose, fn) {
                 logger_1.logger.info(err.stack);
             }
         }
+        if (client_1.daemonClient.enabled()) {
+            client_1.daemonClient.reset();
+        }
         return 1;
     }
 }