nx 19.5.6 → 19.6.0-beta.0

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`,
@@ -41,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,
@@ -53,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({
@@ -68,37 +81,65 @@ 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) {
+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';
-    const nxJson = (0, nx_json_1.readNxJson)(tree);
     if (nxJson?.neverConnectToCloud) {
         printCloudConnectionDisabledMessage();
         return null;
     }
     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, nxJson, responseFromCreateNxCloudWorkspace?.token);
-            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/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/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/project-graph/utils/project-configuration-utils.d.ts

@@ -37,6 +37,7 @@ export type ConfigurationResult = {
  */
 export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
 plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
+export declare function findMatchingConfigFiles(projectFiles: string[], pattern: string, include: string[], exclude: string[]): string[];
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 export declare function validateProject(project: ProjectConfiguration, knownProjects: Record<string, ProjectConfiguration>): void;
 export declare function mergeTargetDefaultWithTargetDefinition(targetName: string, project: ProjectConfiguration, targetDefault: Partial<TargetConfiguration>, sourceMap: Record<string, SourceInformation>): TargetConfiguration;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 exports.mergeMetadata = mergeMetadata;
 exports.createProjectConfigurations = createProjectConfigurations;
+exports.findMatchingConfigFiles = findMatchingConfigFiles;
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
 exports.validateProject = validateProject;
 exports.mergeTargetDefaultWithTargetDefinition = mergeTargetDefaultWithTargetDefinition;

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/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/command-line-utils.d.ts

@@ -29,6 +29,7 @@ export interface NxArgs {
     nxIgnoreCycles?: boolean;
     type?: string;
     batch?: boolean;
+    excludeTaskDependencies?: boolean;
 }
 export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
 export declare function splitArgsIntoNxArgsAndOverrides(args: {

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-json.d.ts

@@ -1,13 +1,6 @@
-import { InputDefinition, ProjectMetadata, TargetConfiguration } from '../config/workspace-json-project-json';
+import { ProjectConfiguration, ProjectMetadata, TargetConfiguration } from '../config/workspace-json-project-json';
 import { PackageManagerCommands } from './package-manager';
-export interface NxProjectPackageJsonConfiguration {
-    name?: string;
-    implicitDependencies?: string[];
-    tags?: string[];
-    namedInputs?: {
-        [inputName: string]: (string | InputDefinition)[];
-    };
-    targets?: Record<string, TargetConfiguration>;
+export interface NxProjectPackageJsonConfiguration extends Partial<ProjectConfiguration> {
     includedScripts?: string[];
 }
 export type ArrayPackageGroup = {