nx 19.5.6 → 19.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.5.6",
+  "version": "19.5.7",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -71,7 +71,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.5.6"
+    "@nrwl/tao": "19.5.7"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.5.6",
-    "@nx/nx-darwin-arm64": "19.5.6",
-    "@nx/nx-linux-x64-gnu": "19.5.6",
-    "@nx/nx-linux-x64-musl": "19.5.6",
-    "@nx/nx-win32-x64-msvc": "19.5.6",
-    "@nx/nx-linux-arm64-gnu": "19.5.6",
-    "@nx/nx-linux-arm64-musl": "19.5.6",
-    "@nx/nx-linux-arm-gnueabihf": "19.5.6",
-    "@nx/nx-win32-arm64-msvc": "19.5.6",
-    "@nx/nx-freebsd-x64": "19.5.6"
+    "@nx/nx-darwin-x64": "19.5.7",
+    "@nx/nx-darwin-arm64": "19.5.7",
+    "@nx/nx-linux-x64-gnu": "19.5.7",
+    "@nx/nx-linux-x64-musl": "19.5.7",
+    "@nx/nx-win32-x64-msvc": "19.5.7",
+    "@nx/nx-linux-arm64-gnu": "19.5.7",
+    "@nx/nx-linux-arm64-musl": "19.5.7",
+    "@nx/nx-linux-arm-gnueabihf": "19.5.7",
+    "@nx/nx-win32-arm64-msvc": "19.5.7",
+    "@nx/nx-freebsd-x64": "19.5.7"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/adapter/compat.d.ts

@@ -1,2 +1,2 @@
 export declare const allowedProjectExtensions: readonly ["tags", "implicitDependencies", "configFilePath", "$schema", "generators", "namedInputs", "name", "files", "root", "sourceRoot", "projectType", "release", "includedScripts", "metadata"];
-export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins"];
+export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud"];

package/src/adapter/compat.js

@@ -60,6 +60,7 @@ exports.allowedWorkspaceExtensions = [
     'cacheDirectory',
     'useDaemonProcess',
     'useInferencePlugins',
+    'neverConnectToCloud',
 ];
 if (!patched) {
     Module.prototype.require = function () {

package/src/command-line/connect/connect-to-nx-cloud.js

@@ -55,12 +55,15 @@ async function connectWorkspaceToCloud(options, directory = workspace_root_1.wor
 }
 async function connectToNxCloudCommand(command) {
     const nxJson = (0, configuration_1.readNxJson)();
+    const installationSource = process.env.NX_CONSOLE
+        ? 'nx-console'
+        : 'nx-connect';
     if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
         const token = process.env.NX_CLOUD_ACCESS_TOKEN || nxJson.nxCloudAccessToken;
         if (!token) {
             throw new Error(`Unable to authenticate. Either define accessToken in nx.json or set the NX_CLOUD_ACCESS_TOKEN env variable.`);
         }
-        const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-connect', token);
+        const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)(installationSource, token);
         output_1.output.log({
             title: '✔ This workspace already has Nx Cloud set up',
             bodyLines: [
@@ -73,7 +76,7 @@ async function connectToNxCloudCommand(command) {
         return false;
     }
     const token = await connectWorkspaceToCloud({
-        installationSource: command ?? 'nx-connect',
+        installationSource: command ?? installationSource,
     });
     const connectCloudUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-connect', token);
     try {

package/src/config/nx-json.d.ts

@@ -404,6 +404,10 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * Set this to false to disable adding inference plugins when generating new projects
      */
     useInferencePlugins?: boolean;
+    /**
+     * Set this to false to disable connection to Nx Cloud
+     */
+    neverConnectToCloud?: boolean;
 }
 export type PluginConfiguration = string | ExpandedPluginConfiguration;
 export type ExpandedPluginConfiguration<T = unknown> = {

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.d.ts

@@ -1,4 +1,5 @@
 import { Tree } from '../../../generators/tree';
+import { NxJsonConfiguration } from '../../../config/nx-json';
 export declare function printSuccessMessage(token: string | undefined, installationSource: string, usesGithub: boolean): Promise<string>;
 export interface ConnectToNxCloudOptions {
     analytics?: boolean;
@@ -7,5 +8,6 @@ export interface ConnectToNxCloudOptions {
     github?: boolean;
     directory?: string;
 }
-export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions): Promise<string>;
-export default connectToNxCloud;
+export declare function connectToNxCloud(tree: Tree, schema: ConnectToNxCloudOptions, nxJson?: NxJsonConfiguration<string[] | "*">): Promise<string>;
+declare function connectToNxCloudGenerator(tree: Tree, options: ConnectToNxCloudOptions): Promise<void>;
+export default connectToNxCloudGenerator;

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

@@ -9,6 +9,7 @@ const nx_json_1 = require("../../../generators/utils/nx-json");
 const format_changed_files_with_prettier_if_available_1 = require("../../../generators/internal-utils/format-changed-files-with-prettier-if-available");
 const url_shorten_1 = require("../../utilities/url-shorten");
 const get_cloud_options_1 = require("../../utilities/get-cloud-options");
+const path_1 = require("path");
 function printCloudConnectionDisabledMessage() {
     output_1.output.error({
         title: `Connections to Nx Cloud are disabled for this workspace`,
@@ -68,20 +69,21 @@ async function printSuccessMessage(token, installationSource, usesGithub) {
     });
     return connectCloudUrl;
 }
-function addNxCloudOptionsToNxJson(tree, nxJson, token) {
-    nxJson ??= {
-        extends: 'nx/presets/npm.json',
-    };
-    nxJson.nxCloudAccessToken = token;
-    const overrideUrl = process.env.NX_CLOUD_API || process.env.NRWL_API;
-    if (overrideUrl) {
-        nxJson.nxCloudUrl = overrideUrl;
+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) => {
+            const overrideUrl = process.env.NX_CLOUD_API || process.env.NRWL_API;
+            if (overrideUrl) {
+                nxJson.nxCloudUrl = overrideUrl;
+            }
+            nxJson.nxCloudAccessToken = token;
+            return nxJson;
+        });
     }
-    (0, nx_json_1.updateNxJson)(tree, nxJson);
 }
-async function connectToNxCloud(tree, schema) {
+async function connectToNxCloud(tree, schema, nxJson = (0, nx_json_1.readNxJson)(tree)) {
     schema.installationSource ??= 'user';
-    const nxJson = (0, nx_json_1.readNxJson)(tree);
     if (nxJson?.neverConnectToCloud) {
         printCloudConnectionDisabledMessage();
         return null;
@@ -91,9 +93,11 @@ async function connectToNxCloud(tree, schema) {
         let responseFromCreateNxCloudWorkspace;
         // do NOT create Nx Cloud token (createNxCloudWorkspace)
         // if user is using github and is running nx-connect
-        if (!(usesGithub && schema.installationSource === 'nx-connect')) {
+        if (!(usesGithub &&
+            (schema.installationSource === 'nx-connect' ||
+                schema.installationSource === 'nx-console'))) {
             responseFromCreateNxCloudWorkspace = await createNxCloudWorkspace(getRootPackageName(tree), schema.installationSource, getNxInitDate());
-            addNxCloudOptionsToNxJson(tree, nxJson, responseFromCreateNxCloudWorkspace?.token);
+            addNxCloudOptionsToNxJson(tree, responseFromCreateNxCloudWorkspace?.token, schema.directory);
             await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
                 silent: schema.hideFormatLogs,
             });
@@ -101,4 +105,7 @@ async function connectToNxCloud(tree, schema) {
         }
     }
 }
-exports.default = connectToNxCloud;
+async function connectToNxCloudGenerator(tree, options) {
+    await connectToNxCloud(tree, options);
+}
+exports.default = connectToNxCloudGenerator;

package/src/nx-cloud/utilities/get-cloud-options.d.ts

@@ -1,4 +1,4 @@
 import { CloudTaskRunnerOptions } from '../nx-cloud-tasks-runner-shell';
-export declare function getCloudOptions(): CloudTaskRunnerOptions;
+export declare function getCloudOptions(directory?: string): CloudTaskRunnerOptions;
 export declare function getCloudUrl(): string;
 export declare function removeTrailingSlash(apiUrl: string): string;

package/src/nx-cloud/utilities/get-cloud-options.js

@@ -5,8 +5,9 @@ exports.getCloudUrl = getCloudUrl;
 exports.removeTrailingSlash = removeTrailingSlash;
 const nx_json_1 = require("../../config/nx-json");
 const run_command_1 = require("../../tasks-runner/run-command");
-function getCloudOptions() {
-    const nxJson = (0, nx_json_1.readNxJson)();
+const workspace_root_1 = require("../../utils/workspace-root");
+function getCloudOptions(directory = workspace_root_1.workspaceRoot) {
+    const nxJson = (0, nx_json_1.readNxJson)(directory);
     // TODO: The default is not always cloud? But it's not handled at the moment
     return (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
 }

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/cache.js

@@ -25,7 +25,7 @@ class Cache {
         if (shouldSpawnProcess) {
             const scriptPath = require.resolve('./remove-old-cache-records.js');
             try {
-                const p = (0, child_process_1.spawn)('node', [scriptPath, `"${this.cachePath}"`], {
+                const p = (0, child_process_1.spawn)('node', [scriptPath, `${this.cachePath}`], {
                     stdio: 'ignore',
                     detached: true,
                     shell: false,

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