nx 17.0.3 → 17.0.5

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

@@ -1,6 +1,8 @@
 "use strict";
+var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProjectGraphAsync = exports.buildProjectGraphWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+exports.createProjectGraphAndSourceMapsAsync = exports.createProjectGraphAsync = exports.ProjectGraphError = exports.buildProjectGraphAndSourceMapsWithoutDaemon = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectConfiguration = exports.readCachedProjectGraph = void 0;
+const tslib_1 = require("tslib");
 const nx_deps_cache_1 = require("./nx-deps-cache");
 const build_project_graph_1 = require("./build-project-graph");
 const output_1 = require("../utils/output");
@@ -13,6 +15,7 @@ const perf_hooks_1 = require("perf_hooks");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const nx_json_1 = require("../config/nx-json");
 const nx_plugin_1 = require("../utils/nx-plugin");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -24,7 +27,7 @@ function readCachedProjectGraph() {
             ? (0, strip_indents_1.stripIndents) `
       Make sure invoke 'node ./decorate-angular-cli.js' in your postinstall script.
       The decorated CLI will compute the project graph.
-      'ng --help' should say 'Smart, Fast and Extensible Build System'.
+      'ng --help' should say 'Smart Monorepos · Fast CI'.
       `
             : '';
         throw new Error((0, strip_indents_1.stripIndents) `
@@ -65,24 +68,132 @@ function readProjectsConfigurationFromProjectGraph(projectGraph) {
     };
 }
 exports.readProjectsConfigurationFromProjectGraph = readProjectsConfigurationFromProjectGraph;
-async function buildProjectGraphWithoutDaemon() {
+async function buildProjectGraphAndSourceMapsWithoutDaemon() {
+    // Set this globally to allow plugins to know if they are being called from the project graph creation
+    global.NX_GRAPH_CREATION = true;
     const nxJson = (0, nx_json_1.readNxJson)();
-    const { allWorkspaceFiles, fileMap, projectConfigurations, externalNodes } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, nxJson);
+    perf_hooks_1.performance.mark('retrieve-project-configurations:start');
+    let configurationResult;
+    let projectConfigurationsError;
+    try {
+        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(workspace_root_1.workspaceRoot, nxJson);
+    }
+    catch (e) {
+        if (e instanceof project_configuration_utils_1.ProjectConfigurationsError) {
+            projectConfigurationsError = e;
+            configurationResult = e.partialProjectConfigurationsResult;
+        }
+        else {
+            throw e;
+        }
+    }
+    const { projects, externalNodes, sourceMaps, projectRootMap } = configurationResult;
+    perf_hooks_1.performance.mark('retrieve-project-configurations:end');
+    perf_hooks_1.performance.mark('retrieve-workspace-files:start');
+    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
-    const projectGraph = (await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projectConfigurations.projects, externalNodes, fileMap, allWorkspaceFiles, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, cacheEnabled)).projectGraph;
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
+    let createDependenciesError;
+    let projectGraphResult;
+    try {
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null);
+    }
+    catch (e) {
+        if (e instanceof build_project_graph_1.CreateDependenciesError) {
+            projectGraphResult = {
+                projectGraph: e.partialProjectGraph,
+                projectFileMapCache: null,
+            };
+            createDependenciesError = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    const { projectGraph, projectFileMapCache } = projectGraphResult;
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
     (0, nx_plugin_1.unregisterPluginTSTranspiler)();
-    return projectGraph;
+    delete global.NX_GRAPH_CREATION;
+    const errors = [
+        ...(projectConfigurationsError?.errors ?? []),
+        ...(createDependenciesError?.errors ?? []),
+    ];
+    if (errors.length > 0) {
+        throw new ProjectGraphError(errors, projectGraph, sourceMaps);
+    }
+    else {
+        if (cacheEnabled) {
+            (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
+        }
+        return { projectGraph, sourceMaps };
+    }
+}
+exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;
+class ProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph, partialSourceMaps) {
+        super(`Failed to process project graph.`);
+        _ProjectGraphError_errors.set(this, void 0);
+        _ProjectGraphError_partialProjectGraph.set(this, void 0);
+        _ProjectGraphError_partialSourceMaps.set(this, void 0);
+        this.name = this.constructor.name;
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_errors, errors, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialProjectGraph, partialProjectGraph, "f");
+        tslib_1.__classPrivateFieldSet(this, _ProjectGraphError_partialSourceMaps, partialSourceMaps, "f");
+        this.stack = `${this.message}\n  ${errors
+            .map((error) => error.stack.split('\n').join('\n  '))
+            .join('\n')}`;
+    }
+    /**
+     * The daemon cannot throw errors which contain methods as they are not serializable.
+     *
+     * This method creates a new {@link ProjectGraphError} from a {@link DaemonProjectGraphError} with the methods based on the same serialized data.
+     */
+    static fromDaemonProjectGraphError(e) {
+        return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
+    }
+    /**
+     * This gets the partial project graph despite the errors which occured.
+     * This partial project graph may be missing nodes, properties of nodes, or dependencies.
+     * This is useful mostly for visualization/debugging. It should not be used for running tasks.
+     */
+    getPartialProjectGraph() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialProjectGraph, "f");
+    }
+    getPartialSourcemaps() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_partialSourceMaps, "f");
+    }
+    getErrors() {
+        return tslib_1.__classPrivateFieldGet(this, _ProjectGraphError_errors, "f");
+    }
 }
-exports.buildProjectGraphWithoutDaemon = buildProjectGraphWithoutDaemon;
+exports.ProjectGraphError = ProjectGraphError;
+_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
 function handleProjectGraphError(opts, e) {
     if (opts.exitOnError) {
-        const lines = e.message.split('\n');
-        output_1.output.error({
-            title: lines[0],
-            bodyLines: lines.slice(1),
-        });
-        if (process.env.NX_VERBOSE_LOGGING === 'true') {
-            console.error(e);
+        const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+        if (e instanceof ProjectGraphError) {
+            let title = e.message;
+            if (isVerbose) {
+                title += ' See errors below.';
+            }
+            const bodyLines = isVerbose
+                ? [e.stack]
+                : ['Pass --verbose to see the stacktraces.'];
+            output_1.output.error({
+                title,
+                bodyLines: bodyLines,
+            });
+        }
+        else {
+            const lines = e.message.split('\n');
+            output_1.output.error({
+                title: lines[0],
+                bodyLines: lines.slice(1),
+            });
+            if (isVerbose) {
+                console.error(e);
+            }
         }
         process.exit(1);
     }
@@ -114,11 +225,22 @@ function handleProjectGraphError(opts, e) {
 async function createProjectGraphAsync(opts = {
     exitOnError: false,
     resetDaemonClient: false,
+}) {
+    const projectGraphAndSourceMaps = await createProjectGraphAndSourceMapsAsync(opts);
+    return projectGraphAndSourceMaps.projectGraph;
+}
+exports.createProjectGraphAsync = createProjectGraphAsync;
+async function createProjectGraphAndSourceMapsAsync(opts = {
+    exitOnError: false,
+    resetDaemonClient: false,
 }) {
     perf_hooks_1.performance.mark('create-project-graph-async:start');
     if (!client_1.daemonClient.enabled()) {
         try {
-            const res = await buildProjectGraphWithoutDaemon();
+            const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
+            perf_hooks_1.performance.measure('create-project-graph-async >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
+            perf_hooks_1.performance.measure('create-project-graph-async >> retrieve-workspace-files', 'retrieve-workspace-files:start', 'retrieve-workspace-files:end');
+            perf_hooks_1.performance.measure('create-project-graph-async >> build-project-graph-using-project-file-map', 'build-project-graph-using-project-file-map:start', 'build-project-graph-using-project-file-map:end');
             perf_hooks_1.performance.mark('create-project-graph-async:end');
             perf_hooks_1.performance.measure('create-project-graph-async', 'create-project-graph-async:start', 'create-project-graph-async:end');
             return res;
@@ -129,13 +251,10 @@ async function createProjectGraphAsync(opts = {
     }
     else {
         try {
-            const projectGraph = await client_1.daemonClient.getProjectGraph();
-            if (opts.resetDaemonClient) {
-                client_1.daemonClient.reset();
-            }
+            const projectGraphAndSourceMaps = await client_1.daemonClient.getProjectGraphAndSourceMaps();
             perf_hooks_1.performance.mark('create-project-graph-async:end');
             perf_hooks_1.performance.measure('create-project-graph-async', 'create-project-graph-async:start', 'create-project-graph-async:end');
-            return projectGraph;
+            return projectGraphAndSourceMaps;
         }
         catch (e) {
             if (e.message.indexOf('inotify_add_watch') > -1) {
@@ -148,7 +267,7 @@ async function createProjectGraphAsync(opts = {
                     ],
                 });
                 (0, tmp_dir_1.markDaemonAsDisabled)();
-                return buildProjectGraphWithoutDaemon();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
             }
             if (e.internalDaemonError) {
                 const errorLogFile = (0, tmp_dir_1.writeDaemonLogs)(e.message);
@@ -161,10 +280,15 @@ async function createProjectGraphAsync(opts = {
                     ],
                 });
                 (0, tmp_dir_1.markDaemonAsDisabled)();
-                return buildProjectGraphWithoutDaemon();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
             }
             handleProjectGraphError(opts, e);
         }
+        finally {
+            if (opts.resetDaemonClient) {
+                client_1.daemonClient.reset();
+            }
+        }
     }
 }
-exports.createProjectGraphAsync = createProjectGraphAsync;
+exports.createProjectGraphAndSourceMapsAsync = createProjectGraphAndSourceMapsAsync;

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

@@ -0,0 +1,2 @@
+import { FileData, ProjectFileMap } from '../../config/project-graph';
+export declare function buildAllWorkspaceFiles(projectFileMap: ProjectFileMap, globalFiles: FileData[]): FileData[];

package/src/project-graph/utils/build-all-workspace-files.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAllWorkspaceFiles = void 0;
+const perf_hooks_1 = require("perf_hooks");
+function buildAllWorkspaceFiles(projectFileMap, globalFiles) {
+    perf_hooks_1.performance.mark('get-all-workspace-files:start');
+    let fileData = Object.values(projectFileMap).flat();
+    fileData = fileData
+        .concat(globalFiles)
+        .sort((a, b) => a.file.localeCompare(b.file));
+    perf_hooks_1.performance.mark('get-all-workspace-files:end');
+    perf_hooks_1.performance.measure('get-all-workspace-files', 'get-all-workspace-files:start', 'get-all-workspace-files:end');
+    return fileData;
+}
+exports.buildAllWorkspaceFiles = buildAllWorkspaceFiles;

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -1,11 +1,10 @@
 import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
-import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
 import { CreateDependenciesContext } from '../../utils/nx-plugin';
-export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder, nxJson: NxJsonConfiguration): Promise<void>;
+export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
 /**
  * Apply target defaults and normalization
  */
-export declare function normalizeProjectTargets(project: ProjectConfiguration, targetDefaults: NxJsonConfiguration['targetDefaults'], projectName: string): Record<string, TargetConfiguration>;
+export declare function normalizeProjectTargets(project: ProjectConfiguration, projectName: string): Record<string, TargetConfiguration>;
 export declare function normalizeImplicitDependencies(source: string, implicitDependencies: ProjectConfiguration['implicitDependencies'], projects: Record<string, ProjectGraphProjectNode>): string[];

package/src/project-graph/utils/normalize-project-nodes.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
-const logger_1 = require("../../utils/logger");
 const project_configuration_utils_1 = require("../utils/project-configuration-utils");
-async function normalizeProjectNodes(ctx, builder, nxJson) {
+async function normalizeProjectNodes(ctx, builder) {
     const toAdd = [];
     // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
     // This is important to ensure that expanded properties referencing projects (e.g. implicit dependencies)
@@ -15,7 +14,7 @@ async function normalizeProjectNodes(ctx, builder, nxJson) {
         const projectConfiguration = ctx.projects[project];
         graph[project] = {
             name: project,
-            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app',
+            type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
             data: {
                 ...projectConfiguration,
             },
@@ -25,7 +24,7 @@ async function normalizeProjectNodes(ctx, builder, nxJson) {
     for (const key of projects) {
         const p = ctx.projects[key];
         p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
-        p.targets = normalizeProjectTargets(p, nxJson.targetDefaults, key);
+        p.targets = normalizeProjectTargets(p, key);
         // TODO: remove in v16
         const projectType = p.projectType === 'application'
             ? key.endsWith('-e2e') || key === 'e2e'
@@ -62,19 +61,13 @@ exports.normalizeProjectNodes = normalizeProjectNodes;
 /**
  * Apply target defaults and normalization
  */
-function normalizeProjectTargets(project, targetDefaults, projectName) {
+function normalizeProjectTargets(project, projectName) {
     // Any node on the graph will have a targets object, it just may be empty
     const targets = project.targets ?? {};
     for (const target in targets) {
-        // We need to know the executor for use in readTargetDefaultsForTarget,
-        // but we haven't resolved the `command` syntactic sugar yet.
-        const executor = targets[target].executor ??
-            (targets[target].command ? 'nx:run-commands' : null);
-        // Allows things like { targetDefaults: { build: { command: tsc } } }
-        const defaults = resolveCommandSyntacticSugar((0, project_configuration_utils_1.readTargetDefaultsForTarget)(target, targetDefaults, executor), `targetDefaults:${target}`);
-        targets[target] = resolveCommandSyntacticSugar(targets[target], `${projectName}:${target}`);
-        if (defaults) {
-            targets[target] = (0, project_configuration_utils_1.mergeTargetConfigurations)(project, target, defaults);
+        if (!targets[target].command && !targets[target].executor) {
+            delete targets[target];
+            continue;
         }
         targets[target].options = (0, project_configuration_utils_1.resolveNxTokensInOptions)(targets[target].options, project, `${projectName}:${target}`);
         targets[target].configurations ??= {};
@@ -97,22 +90,3 @@ function normalizeImplicitDependencies(source, implicitDependencies, projects) {
         .concat(implicitDependencies.filter((x) => x.startsWith('!'))));
 }
 exports.normalizeImplicitDependencies = normalizeImplicitDependencies;
-function resolveCommandSyntacticSugar(target, key) {
-    const { command, ...config } = target ?? {};
-    if (!command) {
-        return target;
-    }
-    if (config.executor) {
-        throw new Error(`${logger_1.NX_PREFIX} ${key} should not have executor and command both configured.`);
-    }
-    else {
-        return {
-            ...config,
-            executor: 'nx:run-commands',
-            options: {
-                ...config.options,
-                command: command,
-            },
-        };
-    }
-}

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -2,13 +2,75 @@ import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
 import { LoadedNxPlugin } from '../../utils/nx-plugin';
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration): void;
-export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
-plugins: LoadedNxPlugin[], root?: string): {
+import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/target-defaults-plugin';
+export type SourceInformation = [file: string, plugin: string];
+export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
+    targets?: Record<string, TargetConfiguration & {
+        [ONLY_MODIFIES_EXISTING_TARGET]?: boolean;
+    }>;
+}, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipCommandNormalization?: boolean): void;
+export type ConfigurationResult = {
     projects: Record<string, ProjectConfiguration>;
     externalNodes: Record<string, ProjectGraphExternalNode>;
+    projectRootMap: Record<string, string>;
+    sourceMaps: ConfigurationSourceMaps;
 };
+/**
+ * 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
+ */
+export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, workspaceFiles: string[], // making this parameter allows devkit to pick up newly created projects
+plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
-export declare function mergeTargetConfigurations(projectConfiguration: ProjectConfiguration, target: string, targetDefaults: TargetDefaults[string]): TargetConfiguration;
+export declare class ProjectConfigurationsError extends Error {
+    readonly errors: Array<MergeNodesError | CreateNodesError>;
+    readonly partialProjectConfigurationsResult: ConfigurationResult;
+    constructor(errors: Array<MergeNodesError | CreateNodesError>, partialProjectConfigurationsResult: ConfigurationResult);
+}
+export declare class CreateNodesError extends Error {
+    file: string;
+    pluginName: string;
+    constructor({ file, pluginName, error, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+    });
+}
+export declare class MergeNodesError extends Error {
+    file: string;
+    pluginName: string;
+    constructor({ file, pluginName, error, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+    });
+}
+/**
+ * Merges two targets.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The target definition with higher priority
+ * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
+ * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
+ * @param sourceInformation The metadata about where the new target was defined
+ * @param targetIdentifier The identifier for the target to merge, used for source map
+ * @returns A merged target configuration
+ */
+export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget?: TargetConfiguration, projectConfigSourceMap?: Record<string, SourceInformation>, sourceInformation?: SourceInformation, targetIdentifier?: string): TargetConfiguration;
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
 export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
 export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];