nx 19.6.0-canary.20240806-a3869a8 → 19.6.0-canary.20240809-d3747e0

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -42,7 +42,7 @@ function getNxInitDate() {
         return null;
     }
 }
-async function createNxCloudWorkspace(workspaceName, installationSource, nxInitDate) {
+async function createNxCloudWorkspaceV1(workspaceName, installationSource, nxInitDate) {
     const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
     const response = await require('axios').post(`${apiUrl}/nx-cloud/create-org-and-workspace`, {
         workspaceName,
@@ -54,6 +54,18 @@ async function createNxCloudWorkspace(workspaceName, installationSource, nxInitD
     }
     return response.data;
 }
+async function createNxCloudWorkspaceV2(workspaceName, installationSource, nxInitDate) {
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    const response = await require('axios').post(`${apiUrl}/nx-cloud/v2/create-org-and-workspace`, {
+        workspaceName,
+        installationSource,
+        nxInitDate,
+    });
+    if (response.data.message) {
+        throw new Error(response.data.message);
+    }
+    return response.data;
+}
 async function printSuccessMessage(token, installationSource, usesGithub) {
     const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)(installationSource, token, usesGithub);
     output_1.output.note({
@@ -69,7 +81,7 @@ async function printSuccessMessage(token, installationSource, usesGithub) {
     });
     return connectCloudUrl;
 }
-function addNxCloudOptionsToNxJson(tree, token, directory = tree.root) {
+function addNxCloudOptionsToNxJson(tree, token, directory = '') {
     const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
     if (tree.exists(nxJsonPath)) {
         (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {
@@ -82,6 +94,19 @@ function addNxCloudOptionsToNxJson(tree, token, directory = tree.root) {
         });
     }
 }
+function addNxCloudIdToNxJson(tree, nxCloudId, directory = tree.root) {
+    const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
+    if (tree.exists(nxJsonPath)) {
+        (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {
+            const overrideUrl = process.env.NX_CLOUD_API || process.env.NRWL_API;
+            if (overrideUrl) {
+                nxJson.nxCloudUrl = overrideUrl;
+            }
+            nxJson.nxCloudId = nxCloudId;
+            return nxJson;
+        });
+    }
+}
 async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)(tree)) {
     schema.installationSource ??= 'user';
     if (nxJson?.neverConnectToCloud) {
@@ -90,17 +115,31 @@ async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)
     }
     else {
         const usesGithub = schema.github ?? (await (0, url_shorten_1.repoUsesGithub)(schema.github));
-        let responseFromCreateNxCloudWorkspace;
+        let responseFromCreateNxCloudWorkspaceV1;
+        let responseFromCreateNxCloudWorkspaceV2;
         // do NOT create Nx Cloud token (createNxCloudWorkspace)
         // if user is using github and is running nx-connect
         if (!(usesGithub && schema.installationSource === 'nx-connect')) {
-            responseFromCreateNxCloudWorkspace = await createNxCloudWorkspace(getRootPackageName(tree), schema.installationSource, getNxInitDate());
-            addNxCloudOptionsToNxJson(tree, responseFromCreateNxCloudWorkspace?.token, schema.directory);
-            await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
-                silent: schema.hideFormatLogs,
-            });
-            return responseFromCreateNxCloudWorkspace.token;
+            if (process.env.NX_ENABLE_LOGIN === 'true') {
+                responseFromCreateNxCloudWorkspaceV2 = await createNxCloudWorkspaceV2(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+                addNxCloudIdToNxJson(tree, responseFromCreateNxCloudWorkspaceV2?.nxCloudId, schema.directory);
+                await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+                    silent: schema.hideFormatLogs,
+                });
+                return responseFromCreateNxCloudWorkspaceV2.nxCloudId;
+            }
+            else {
+                responseFromCreateNxCloudWorkspaceV1 = await createNxCloudWorkspaceV1(getRootPackageName(tree), schema.installationSource, getNxInitDate());
+                addNxCloudOptionsToNxJson(tree, responseFromCreateNxCloudWorkspaceV1?.token, schema.directory);
+                await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+                    silent: schema.hideFormatLogs,
+                });
+                return responseFromCreateNxCloudWorkspaceV1.token;
+            }
         }
     }
 }
-exports.default = connectToNxCloud;
+async function connectToNxCloudGenerator(tree, options) {
+    await connectToNxCloud(tree, options);
+}
+exports.default = connectToNxCloudGenerator;

package/src/nx-cloud/nx-cloud-tasks-runner-shell.d.ts

@@ -11,5 +11,6 @@ export interface CloudTaskRunnerOptions extends DefaultTasksRunnerOptions {
     url?: string;
     useLightClient?: boolean;
     clientVersion?: string;
+    nxCloudId?: string;
 }
 export declare const nxCloudTasksRunnerShell: TasksRunner<CloudTaskRunnerOptions>;

package/src/nx-cloud/utilities/axios.js

@@ -8,8 +8,15 @@ function createApiAxiosInstance(options) {
     let axiosConfigBuilder = (axiosConfig) => axiosConfig;
     const baseUrl = process.env.NX_CLOUD_API || options.url || 'https://cloud.nx.app';
     const accessToken = environment_1.ACCESS_TOKEN ? environment_1.ACCESS_TOKEN : options.accessToken;
-    if (!accessToken) {
-        throw new Error(`Unable to authenticate. Either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable.`);
+    const nxCloudId = options.nxCloudId;
+    // TODO(lourw): Update message with NxCloudId once it is supported
+    if (!accessToken && !nxCloudId) {
+        if (process.env.NX_ENABLE_LOGIN === 'true' && !nxCloudId) {
+            throw new Error(`Unable to authenticate. Please connect your workspace to Nx Cloud to define a valid Nx Cloud Id. If you are in a CI context, please set the NX_CLOUD_ACCESS_TOKEN environment variable or define an access token in your nx.json.`);
+        }
+        else {
+            throw new Error(`Unable to authenticate. Either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable. If you do not want to use Nx Cloud for this command, either set NX_NO_CLOUD=true, or pass the --no-cloud flag.`);
+        }
     }
     if (options.customProxyConfigPath) {
         const { nxCloudProxyConfig } = require((0, path_1.join)(process.cwd(), options.customProxyConfigPath));

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -141,9 +141,14 @@ class TargetProjectLocator {
             }
             const version = (0, semver_1.clean)(externalPackageJson.version);
             const npmProjectKey = `npm:${externalPackageJson.name}@${version}`;
-            const matchingExternalNode = this.npmProjects[npmProjectKey];
+            let matchingExternalNode = this.npmProjects[npmProjectKey];
             if (!matchingExternalNode) {
-                return null;
+                // check if it's a package alias, where the resolved package key is used as the version
+                const aliasNpmProjectKey = `npm:${packageName}@${npmProjectKey}`;
+                matchingExternalNode = this.npmProjects[aliasNpmProjectKey];
+                if (!matchingExternalNode) {
+                    return null;
+                }
             }
             this.npmResolutionCache.set(npmImportForProject, matchingExternalNode.name);
             return matchingExternalNode.name;

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

@@ -90,7 +90,15 @@ function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, pa
     const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
     if (siblingProjectJson) {
         for (const target of Object.keys(siblingProjectJson?.targets ?? {})) {
-            delete packageJson.scripts?.[target];
+            const { executor, command, options } = siblingProjectJson.targets[target];
+            if (
+            // will use run-commands, different target
+            command ||
+                // Either uses a different executor or runs a different script
+                (executor &&
+                    (executor !== 'nx:run-script' || options?.script !== target))) {
+                delete packageJson.scripts?.[target];
+            }
         }
     }
     if (!packageJson.name && projectRoot === '.') {

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 };
 }