nx 18.2.0-canary.20240321-2a4c57d → 18.2.0-canary.20240323-54d4780

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.MergeNodesError = exports.CreateNodesError = exports.ProjectConfigurationsError = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const logger_1 = require("../../utils/logger");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
 const target_defaults_plugin_1 = require("../../plugins/target-defaults/target-defaults-plugin");
 const minimatch_1 = require("minimatch");
 const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -208,25 +209,44 @@ exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRoot
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
+ * @param root The workspace root
  * @param nxJson The NxJson configuration
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
- * @param root The workspace root
  */
-function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson, workspaceFiles, // making this parameter allows devkit to pick up newly created projects
-plugins, root = workspace_root_1.workspaceRoot) {
+function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, workspaceFiles, // making this parameter allows devkit to pick up newly created projects
+plugins) {
+    perf_hooks_1.performance.mark('build-project-configs:start');
     const results = [];
+    const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const { plugin, options } of plugins) {
+    for (const { plugin, options, include, exclude } of plugins) {
         const [pattern, createNodes] = plugin.createNodes ?? [];
         const pluginResults = [];
-        performance.mark(`${plugin.name}:createNodes - start`);
+        perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
         if (!pattern) {
             continue;
         }
-        const matchingConfigFiles = workspaceFiles.filter(minimatch_1.minimatch.filter(pattern, { dot: true }));
+        const matchingConfigFiles = [];
+        for (const file of workspaceFiles) {
+            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
+                if (include) {
+                    const included = include.some((includedPattern) => (0, minimatch_1.minimatch)(file, includedPattern, { dot: true }));
+                    if (!included) {
+                        continue;
+                    }
+                }
+                if (exclude) {
+                    const excluded = include.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
+                    if (excluded) {
+                        continue;
+                    }
+                }
+                matchingConfigFiles.push(file);
+            }
+        }
         for (const file of matchingConfigFiles) {
-            performance.mark(`${plugin.name}:createNodes:${file} - start`);
+            perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - start`);
             try {
                 let r = createNodes(file, options, {
                     nxJsonConfiguration: nxJson,
@@ -235,19 +255,26 @@ plugins, root = workspace_root_1.workspaceRoot) {
                 });
                 if (r instanceof Promise) {
                     pluginResults.push(r
-                        .catch((e) => {
-                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+                        .catch((error) => {
+                        perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                        errors.push(new CreateNodesError({
+                            file,
+                            pluginName: plugin.name,
+                            error,
+                        }));
+                        return {
+                            projects: {},
+                        };
                     })
                         .then((r) => {
-                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+                        perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                        perf_hooks_1.performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
                         return { ...r, file, pluginName: plugin.name };
                     }));
                 }
                 else {
-                    performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                    performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
+                    perf_hooks_1.performance.mark(`${plugin.name}:createNodes:${file} - end`);
+                    perf_hooks_1.performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
                     pluginResults.push({
                         ...r,
                         file,
@@ -255,19 +282,22 @@ plugins, root = workspace_root_1.workspaceRoot) {
                     });
                 }
             }
-            catch (e) {
-                throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
+            catch (error) {
+                errors.push(new CreateNodesError({
+                    file,
+                    pluginName: plugin.name,
+                    error,
+                }));
             }
         }
-        // If there are no promises (counter undefined) or all promises have resolved (counter === 0)
         results.push(Promise.all(pluginResults).then((results) => {
-            performance.mark(`${plugin.name}:createNodes - end`);
-            performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+            perf_hooks_1.performance.mark(`${plugin.name}:createNodes - end`);
+            perf_hooks_1.performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
             return results;
         }));
     }
     return Promise.all(results).then((results) => {
-        performance.mark('createNodes:merge - start');
+        perf_hooks_1.performance.mark('createNodes:merge - start');
         const projectRootMap = new Map();
         const externalNodes = {};
         const configurationSourceMaps = {};
@@ -285,25 +315,41 @@ plugins, root = workspace_root_1.workspaceRoot) {
                 try {
                     mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
                 }
-                catch (e) {
-                    throw new CreateNodesError(`Unable to merge project information for "${project.root}" from ${result.file} using plugin ${result.pluginName}.`, e);
+                catch (error) {
+                    errors.push(new MergeNodesError({
+                        file,
+                        pluginName,
+                        error,
+                    }));
                 }
             }
             Object.assign(externalNodes, pluginExternalNodes);
         }
         const projects = readProjectConfigurationsFromRootMap(projectRootMap);
         const rootMap = createRootMap(projectRootMap);
-        performance.mark('createNodes:merge - end');
-        performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
-        return {
-            projects,
-            externalNodes,
-            rootMap,
-            sourceMaps: configurationSourceMaps,
-        };
+        perf_hooks_1.performance.mark('createNodes:merge - end');
+        perf_hooks_1.performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
+        perf_hooks_1.performance.mark('build-project-configs:end');
+        perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
+        if (errors.length === 0) {
+            return {
+                projects,
+                externalNodes,
+                projectRootMap: rootMap,
+                sourceMaps: configurationSourceMaps,
+            };
+        }
+        else {
+            throw new ProjectConfigurationsError(errors, {
+                projects,
+                externalNodes,
+                projectRootMap: rootMap,
+                sourceMaps: configurationSourceMaps,
+            });
+        }
     });
 }
-exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = buildProjectsConfigurationsFromProjectPathsAndPlugins;
+exports.createProjectConfigurations = createProjectConfigurations;
 function readProjectConfigurationsFromRootMap(projectRootMap) {
     const projects = {};
     // If there are projects that have the same name, that is an error.
@@ -346,20 +392,37 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     return projects;
 }
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+class ProjectConfigurationsError extends Error {
+    constructor(errors, partialProjectConfigurationsResult) {
+        super('Failed to create project configurations');
+        this.errors = errors;
+        this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectConfigurationsError = ProjectConfigurationsError;
 class CreateNodesError extends Error {
-    constructor(msg, cause) {
-        const message = `${msg} ${!cause
-            ? ''
-            : cause instanceof Error
-                ? `\n\n\t Inner Error: ${cause.stack}`
-                : cause}`;
-        // These errors are thrown during a JS callback which is invoked via rust.
-        // The errors messaging gets lost in the rust -> js -> rust transition, but
-        // logging the error here will ensure that it is visible in the console.
-        console.error(message);
-        super(message, { cause });
+    constructor({ file, pluginName, error, }) {
+        const msg = `The "${pluginName}" plugin threw an error while creating nodes from ${file}:`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.CreateNodesError = CreateNodesError;
+class MergeNodesError extends Error {
+    constructor({ file, pluginName, error, }) {
+        const msg = `The nodes created from ${file} by the "${pluginName}" could not be merged into the project graph:`;
+        super(msg, { cause: error });
+        this.name = this.constructor.name;
+        this.file = file;
+        this.pluginName = pluginName;
+        this.stack = `${this.message}\n  ${error.stack.split('\n').join('\n  ')}`;
     }
 }
+exports.MergeNodesError = MergeNodesError;
 /**
  * Merges two targets.
  *

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -1,7 +1,6 @@
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
-import { ProjectGraphExternalNode } from '../../config/project-graph';
-import { ConfigurationSourceMaps } from './project-configuration-utils';
+import { ConfigurationResult } from './project-configuration-utils';
 import { LoadedNxPlugin } from '../../utils/nx-plugin';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
@@ -10,7 +9,7 @@ import { LoadedNxPlugin } from '../../utils/nx-plugin';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("../../config/project-graph").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
         nonProjectFiles: import("../../native").FileData[];
@@ -23,15 +22,8 @@ export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRoo
  * @param workspaceRoot
  * @param nxJson
  */
-export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<RetrievedGraphNodes>;
-export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<RetrievedGraphNodes>;
-export type RetrievedGraphNodes = {
-    externalNodes: Record<string, ProjectGraphExternalNode>;
-    projects: Record<string, ProjectConfiguration>;
-    sourceMaps: ConfigurationSourceMaps;
-    projectRootMap: Record<string, string>;
-};
+export declare function retrieveProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
+export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
 export declare function retrieveProjectConfigurationPaths(root: string, plugins: LoadedNxPlugin[]): string[];
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: LoadedNxPlugin[]): Promise<RetrievedGraphNodes>;
 export declare function configurationGlobs(plugins: LoadedNxPlugin[]): string[];

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configurationGlobs = exports.createProjectConfigurations = exports.retrieveProjectConfigurationsWithoutPluginInference = exports.retrieveProjectConfigurationPaths = exports.retrieveProjectConfigurationsWithAngularProjects = exports.retrieveProjectConfigurations = exports.retrieveWorkspaceFiles = void 0;
+exports.configurationGlobs = exports.retrieveProjectConfigurationsWithoutPluginInference = exports.retrieveProjectConfigurationPaths = exports.retrieveProjectConfigurationsWithAngularProjects = exports.retrieveProjectConfigurations = exports.retrieveWorkspaceFiles = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const installation_directory_1 = require("../../utils/installation-directory");
 const angular_json_1 = require("../../adapter/angular-json");
@@ -58,7 +58,7 @@ exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfig
 function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins) {
     const globPatterns = configurationGlobs(plugins);
     const workspaceFiles = (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
-    return createProjectConfigurations(workspaceRoot, nxJson, workspaceFiles, plugins);
+    return (0, project_configuration_utils_1.createProjectConfigurations)(workspaceRoot, nxJson, workspaceFiles, plugins);
 }
 function retrieveProjectConfigurationPaths(root, plugins) {
     const projectGlobPatterns = configurationGlobs(plugins);
@@ -76,7 +76,7 @@ async function retrieveProjectConfigurationsWithoutPluginInference(root) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
     const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns) ?? [];
-    const { projects } = await createProjectConfigurations(root, nxJson, projectFiles, [
+    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, [
         { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) },
         { plugin: project_json_1.ProjectJsonProjectsPlugin },
     ]);
@@ -84,19 +84,6 @@ async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     return projects;
 }
 exports.retrieveProjectConfigurationsWithoutPluginInference = retrieveProjectConfigurationsWithoutPluginInference;
-async function createProjectConfigurations(workspaceRoot, nxJson, configFiles, plugins) {
-    perf_hooks_1.performance.mark('build-project-configs:start');
-    const { projects, externalNodes, rootMap, sourceMaps } = await (0, project_configuration_utils_1.buildProjectsConfigurationsFromProjectPathsAndPlugins)(nxJson, configFiles, plugins, workspaceRoot);
-    perf_hooks_1.performance.mark('build-project-configs:end');
-    perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
-    return {
-        projects,
-        externalNodes,
-        projectRootMap: rootMap,
-        sourceMaps,
-    };
-}
-exports.createProjectConfigurations = createProjectConfigurations;
 function configurationGlobs(plugins) {
     const globPatterns = [];
     for (const { plugin } of plugins) {

package/src/tasks-runner/cache.js

@@ -215,18 +215,21 @@ class Cache {
     }
     tryAndRetry(fn) {
         let attempts = 0;
-        const baseTimeout = 100;
+        const baseTimeout = 5;
+        // Generate a random number between 2 and 4 to raise to the power of attempts
+        const baseExponent = Math.random() * 2 + 2;
         const _try = async () => {
             try {
                 attempts++;
                 return await fn();
             }
             catch (e) {
-                if (attempts === 10) {
+                // Max time is 5 * 4^3 = 20480ms
+                if (attempts === 6) {
                     // After enough attempts, throw the error
                     throw e;
                 }
-                await new Promise((res) => setTimeout(res, baseTimeout * attempts));
+                await new Promise((res) => setTimeout(res, baseExponent ** attempts));
                 return await _try();
             }
         };

package/src/utils/nx-plugin.d.ts

@@ -91,6 +91,8 @@ export type NxPlugin = NxPluginV1 | NxPluginV2;
 export type LoadedNxPlugin = {
     plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
     options?: unknown;
+    include?: string[];
+    exclude?: string[];
 };
 export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
 export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {

package/src/utils/nx-plugin.js

@@ -71,8 +71,19 @@ async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
         ? pluginConfiguration
         : { plugin: pluginConfiguration, options: undefined };
     let pluginModule = exports.nxPluginCache.get(moduleName);
+    const include = typeof pluginConfiguration === 'object'
+        ? pluginConfiguration.include
+        : undefined;
+    const exclude = typeof pluginConfiguration === 'object'
+        ? pluginConfiguration.exclude
+        : undefined;
     if (pluginModule) {
-        return { plugin: pluginModule, options };
+        return {
+            plugin: pluginModule,
+            options,
+            include,
+            exclude,
+        };
     }
     performance.mark(`Load Nx Plugin: ${moduleName} - start`);
     let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
@@ -81,7 +92,12 @@ async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
     exports.nxPluginCache.set(moduleName, plugin);
     performance.mark(`Load Nx Plugin: ${moduleName} - end`);
     performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
-    return { plugin, options };
+    return {
+        plugin,
+        options,
+        include,
+        exclude,
+    };
 }
 exports.loadNxPluginAsync = loadNxPluginAsync;
 async function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequirePaths)(), root = workspace_root_1.workspaceRoot, projects) {

package/src/utils/output.d.ts

@@ -1,5 +1,5 @@
 import * as chalk from 'chalk';
-import { TaskStatus } from '../tasks-runner/tasks-runner';
+import type { TaskStatus } from '../tasks-runner/tasks-runner';
 export interface CLIErrorMessageConfig {
     title: string;
     bodyLines?: string[];

package/src/utils/params.d.ts

@@ -1,5 +1,5 @@
-import { NxJsonConfiguration } from '../config/nx-json';
-import { TargetConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { NxJsonConfiguration } from '../config/nx-json';
+import type { TargetConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 type PropertyDescription = {
     type?: string | string[];
     required?: string[];

package/src/utils/params.js

@@ -13,6 +13,20 @@ async function handleErrors(isVerbose, fn) {
         if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
             logger_1.logger.error('The generator workflow failed. See above.');
         }
+        else if (err.name === 'ProjectGraphError') {
+            const projectGraphError = err;
+            let title = projectGraphError.message;
+            if (isVerbose) {
+                title += ' See errors below.';
+            }
+            const bodyLines = isVerbose
+                ? [projectGraphError.stack]
+                : ['Pass --verbose to see the stacktraces.'];
+            output_1.output.error({
+                title,
+                bodyLines: bodyLines,
+            });
+        }
         else {
             const lines = (err.message ? err.message : err.toString()).split('\n');
             const bodyLines = lines.slice(1);