nx 19.6.0-canary.20240806-a3869a8 → 19.6.0-canary.20240808-333ab77

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

@@ -13,7 +13,11 @@ const exit_codes_1 = require("../../../utils/exit-codes");
 const messaging_1 = require("./messaging");
 const cleanupFunctions = new Set();
 const pluginNames = new Map();
-const MAX_MESSAGE_WAIT = 1000 * 60 * 5; // 5 minutes
+const PLUGIN_TIMEOUT_HINT_TEXT = 'As a last resort, you can set NX_PLUGIN_NO_TIMEOUTS=true to bypass this timeout.';
+const MINUTES = 10;
+const MAX_MESSAGE_WAIT = process.env.NX_PLUGIN_NO_TIMEOUTS === 'true'
+    ? undefined
+    : 1000 * 60 * MINUTES; // 10 minutes
 const nxPluginWorkerCache = (global['nxPluginWorkerCache'] ??= new Map());
 async function loadRemoteNxPlugin(plugin, root) {
     const cacheKey = JSON.stringify({ plugin, root });
@@ -36,11 +40,14 @@ async function loadRemoteNxPlugin(plugin, root) {
             payload: { plugin, root },
         });
         // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
-        const loadTimeout = setTimeout(() => {
-            rej(new Error('Plugin worker timed out when loading plugin:' + plugin));
-        }, MAX_MESSAGE_WAIT);
+        const loadTimeout = MAX_MESSAGE_WAIT
+            ? setTimeout(() => {
+                rej(new Error(`Loading "${plugin}" timed out after ${MINUTES} minutes. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
+            }, MAX_MESSAGE_WAIT)
+            : undefined;
         socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(createWorkerHandler(worker, pendingPromises, (val) => {
-            clearTimeout(loadTimeout);
+            if (loadTimeout)
+                clearTimeout(loadTimeout);
             res(val);
         }, rej, socket)));
         worker.on('exit', exitHandler);
@@ -90,6 +97,9 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                                             type: 'createNodes',
                                             payload: { configFiles, context: ctx, tx },
                                         });
+                                    }, {
+                                        plugin: pluginName,
+                                        operation: 'createNodes',
                                     });
                                 },
                             ]
@@ -102,6 +112,9 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                                         type: 'createDependencies',
                                         payload: { context: ctx, tx },
                                     });
+                                }, {
+                                    plugin: pluginName,
+                                    operation: 'createDependencies',
                                 });
                             }
                             : undefined,
@@ -113,6 +126,9 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                                         type: 'processProjectGraph',
                                         payload: { graph, ctx, tx },
                                     });
+                                }, {
+                                    operation: 'processProjectGraph',
+                                    plugin: pluginName,
                                 });
                             }
                             : undefined,
@@ -124,6 +140,9 @@ function createWorkerHandler(worker, pending, onload, onloadError, socket) {
                                         type: 'createMetadata',
                                         payload: { graph, context: ctx, tx },
                                     });
+                                }, {
+                                    plugin: pluginName,
+                                    operation: 'createMetadata',
                                 });
                             }
                             : undefined,
@@ -192,18 +211,21 @@ process.on('SIGINT', () => {
     process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
 });
 process.on('SIGTERM', exitHandler);
-function registerPendingPromise(tx, pending, callback) {
+function registerPendingPromise(tx, pending, callback, context) {
     let resolver, rejector, timeout;
     const promise = new Promise((res, rej) => {
         rejector = rej;
         resolver = res;
-        timeout = setTimeout(() => {
-            rej(new Error(`Plugin worker timed out when processing message ${tx}`));
-        }, MAX_MESSAGE_WAIT);
+        timeout = MAX_MESSAGE_WAIT
+            ? setTimeout(() => {
+                rej(new Error(`${context.plugin} timed out after ${MINUTES} minutes during ${context.operation}. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
+            }, MAX_MESSAGE_WAIT)
+            : undefined;
         callback();
     }).finally(() => {
         pending.delete(tx);
-        clearTimeout(timeout);
+        if (timeout)
+            clearTimeout(timeout);
     });
     pending.set(tx, {
         promise,

package/src/tasks-runner/run-command.js

@@ -318,7 +318,9 @@ function getTasksRunnerPath(runner, nxJson) {
         // No runner prop in tasks runner options, check if access token is set.
         nxJson.tasksRunnerOptions?.[runner]?.options?.accessToken ||
         // Cloud access token specified in env var.
-        process.env.NX_CLOUD_ACCESS_TOKEN;
+        process.env.NX_CLOUD_ACCESS_TOKEN ||
+        // Nx Cloud Id specified in nxJson
+        nxJson.nxCloudId;
     return isCloudRunner ? 'nx-cloud' : require.resolve('./default-tasks-runner');
 }
 function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
@@ -339,6 +341,9 @@ function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
     if (nxJson.nxCloudAccessToken && isCloudDefault) {
         result.accessToken ??= nxJson.nxCloudAccessToken;
     }
+    if (nxJson.nxCloudId && isCloudDefault) {
+        result.nxCloudId ??= nxJson.nxCloudId;
+    }
     if (nxJson.nxCloudUrl && isCloudDefault) {
         result.url ??= nxJson.nxCloudUrl;
     }

package/src/tasks-runner/utils.js

@@ -77,27 +77,31 @@ function expandDependencyConfigSyntaxSugar(dependencyConfigString, graph) {
 }
 // Weakmap let's the cache get cleared by garbage collector if allTargetNames is no longer used
 const patternResultCache = new WeakMap();
-function expandWildcardTargetConfiguration(dependencyConfig, allTargetNames) {
-    if (!(0, globs_1.isGlobPattern)(dependencyConfig.target)) {
-        return [dependencyConfig];
-    }
+function findMatchingTargets(pattern, allTargetNames) {
     let cache = patternResultCache.get(allTargetNames);
     if (!cache) {
         cache = new Map();
         patternResultCache.set(allTargetNames, cache);
     }
-    const cachedResult = cache.get(dependencyConfig.target);
+    const cachedResult = cache.get(pattern);
     if (cachedResult) {
         return cachedResult;
     }
-    const matcher = minimatch_1.minimatch.filter(dependencyConfig.target);
+    const matcher = minimatch_1.minimatch.filter(pattern);
     const matchingTargets = allTargetNames.filter((t) => matcher(t));
-    const result = matchingTargets.map((t) => ({
-        ...dependencyConfig,
+    cache.set(pattern, matchingTargets);
+    return matchingTargets;
+}
+function expandWildcardTargetConfiguration(dependencyConfig, allTargetNames) {
+    if (!(0, globs_1.isGlobPattern)(dependencyConfig.target)) {
+        return [dependencyConfig];
+    }
+    const matchingTargets = findMatchingTargets(dependencyConfig.target, allTargetNames);
+    return matchingTargets.map((t) => ({
         target: t,
+        projects: dependencyConfig.projects,
+        dependencies: dependencyConfig.dependencies,
     }));
-    cache.set(dependencyConfig.target, result);
-    return result;
 }
 function readProjectAndTargetFromTargetString(targetString, projects) {
     // Support for both `project:target` and `target:with:colons` syntax

package/src/utils/nx-cloud-utils.js

@@ -6,12 +6,14 @@ exports.getNxCloudToken = getNxCloudToken;
 function isNxCloudUsed(nxJson) {
     return (!!process.env.NX_CLOUD_ACCESS_TOKEN ||
         !!nxJson.nxCloudAccessToken ||
+        !!nxJson.nxCloudId ||
         !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
 }
 function getNxCloudUrl(nxJson) {
     const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
     if (!cloudRunner &&
-        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
+        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN) &&
+        !nxJson.nxCloudId)
         throw new Error('nx-cloud runner not found in nx.json');
     return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
 }

package/src/utils/package-manager.js

@@ -176,6 +176,7 @@ function getPackageManagerVersion(packageManager = detectPackageManager(), cwd =
         version = (0, child_process_1.execSync)(`${packageManager} --version`, {
             cwd,
             encoding: 'utf-8',
+            windowsHide: true,
         }).trim();
     }
     catch {
@@ -349,7 +350,10 @@ async function resolvePackageVersionUsingInstallation(packageName, version) {
     const { dir, cleanup } = createTempNpmDirectory();
     try {
         const pmc = getPackageManagerCommand();
-        await execAsync(`${pmc.add} ${packageName}@${version}`, { cwd: dir });
+        await execAsync(`${pmc.add} ${packageName}@${version}`, {
+            cwd: dir,
+            windowsHide: true,
+        });
         const { packageJson } = (0, package_json_1.readModulePackageJson)(packageName, [dir]);
         return packageJson.version;
     }
@@ -372,7 +376,9 @@ async function packageRegistryView(pkg, version, args) {
          */
         pm = 'npm';
     }
-    const { stdout } = await execAsync(`${pm} view ${pkg}@${version} ${args}`);
+    const { stdout } = await execAsync(`${pm} view ${pkg}@${version} ${args}`, {
+        windowsHide: true,
+    });
     return stdout.toString().trim();
 }
 async function packageRegistryPack(cwd, pkg, version) {
@@ -389,7 +395,10 @@ async function packageRegistryPack(cwd, pkg, version) {
          */
         pm = 'npm';
     }
-    const { stdout } = await execAsync(`${pm} pack ${pkg}@${version}`, { cwd });
+    const { stdout } = await execAsync(`${pm} pack ${pkg}@${version}`, {
+        cwd,
+        windowsHide: true,
+    });
     const tarballPath = stdout.trim();
     return { tarballPath };
 }