nx 20.8.4 → 22.7.7

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

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFileMap = getFileMap;
+exports.hydrateFileMap = hydrateFileMap;
+exports.buildProjectGraphUsingProjectFileMap = buildProjectGraphUsingProjectFileMap;
+exports.applyProjectMetadata = applyProjectMetadata;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const configuration_1 = require("../config/configuration");
+const file_hasher_1 = require("../hasher/file-hasher");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const assert_workspace_validity_1 = require("../utils/assert-workspace-validity");
+const delayed_spinner_1 = require("../utils/delayed-spinner");
+const fileutils_1 = require("../utils/fileutils");
+const plugin_progress_text_1 = require("../utils/plugin-progress-text");
+const progress_topics_1 = require("../utils/progress-topics");
+const workspace_root_1 = require("../utils/workspace-root");
+const error_types_1 = require("./error-types");
+const nx_deps_cache_1 = require("./nx-deps-cache");
+const project_graph_builder_1 = require("./project-graph-builder");
+const implicit_project_dependencies_1 = require("./utils/implicit-project-dependencies");
+const normalize_project_nodes_1 = require("./utils/normalize-project-nodes");
+const target_merging_1 = require("./utils/project-configuration/target-merging");
+let storedFileMap = null;
+let storedAllWorkspaceFiles = null;
+let storedRustReferences = null;
+function getFileMap() {
+    if (!!storedFileMap) {
+        return {
+            fileMap: storedFileMap,
+            allWorkspaceFiles: storedAllWorkspaceFiles,
+            rustReferences: storedRustReferences,
+        };
+    }
+    else {
+        return {
+            fileMap: {
+                nonProjectFiles: [],
+                projectFileMap: {},
+            },
+            allWorkspaceFiles: [],
+            rustReferences: null,
+        };
+    }
+}
+function hydrateFileMap(fileMap, allWorkspaceFiles, rustReferences) {
+    storedFileMap = fileMap;
+    storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
+}
+async function buildProjectGraphUsingProjectFileMap(projectRootMap, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache, plugins, sourceMap) {
+    storedFileMap = fileMap;
+    storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
+    const projects = {};
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        projects[project.name] = project;
+    }
+    const errors = [];
+    const nxJson = (0, configuration_1.readNxJson)();
+    const projectGraphVersion = '6.0';
+    try {
+        (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
+    }
+    catch (e) {
+        if ((0, error_types_1.isWorkspaceValidityError)(e)) {
+            errors.push(e);
+        }
+    }
+    const packageJsonDeps = readCombinedDeps();
+    const rootTsConfig = readRootTsConfig();
+    const externalNodesHash = hashExternalNodes(externalNodes);
+    let filesToProcess;
+    let cachedFileData;
+    const useCacheData = fileMapCache &&
+        !(0, nx_deps_cache_1.shouldRecomputeWholeGraph)(fileMapCache, packageJsonDeps, projects, nxJson, rootTsConfig, externalNodesHash);
+    if (useCacheData) {
+        const fromCache = (0, nx_deps_cache_1.extractCachedFileData)(fileMap, fileMapCache);
+        filesToProcess = fromCache.filesToProcess;
+        cachedFileData = fromCache.cachedFileData;
+    }
+    else {
+        filesToProcess = fileMap;
+        cachedFileData = {
+            nonProjectFiles: {},
+            projectFileMap: {},
+        };
+    }
+    let projectGraph;
+    let projectFileMapCache;
+    try {
+        const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
+        projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion, plugins, sourceMap);
+        projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig, externalNodesHash);
+    }
+    catch (e) {
+        // we need to include the workspace validity errors in the final error
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            errors.push(...e.errors);
+            throw new error_types_1.AggregateProjectGraphError(errors, e.partialProjectGraph);
+        }
+        else {
+            throw e;
+        }
+    }
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateProjectGraphError(errors, projectGraph);
+    }
+    return {
+        projectGraph,
+        projectFileMapCache,
+    };
+}
+function readCombinedDeps() {
+    const installationPackageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, '.nx', 'installation', 'package.json');
+    const installationPackageJson = (0, fs_1.existsSync)(installationPackageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(installationPackageJsonPath)
+        : {};
+    const rootPackageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json');
+    const rootPackageJson = (0, fs_1.existsSync)(rootPackageJsonPath)
+        ? (0, fileutils_1.readJsonFile)(rootPackageJsonPath)
+        : {};
+    return {
+        ...rootPackageJson.dependencies,
+        ...rootPackageJson.devDependencies,
+        ...installationPackageJson.dependencies,
+        ...installationPackageJson.devDependencies,
+    };
+}
+async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion, plugins, sourceMap) {
+    const builder = new project_graph_builder_1.ProjectGraphBuilder(null, ctx.fileMap.projectFileMap);
+    builder.setVersion(projectGraphVersion);
+    for (const node in knownExternalNodes) {
+        builder.addExternalNode(knownExternalNodes[node]);
+    }
+    await (0, normalize_project_nodes_1.normalizeProjectNodes)(ctx, builder);
+    const initProjectGraph = builder.getUpdatedProjectGraph();
+    let updatedGraph;
+    let error;
+    try {
+        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph, plugins, sourceMap);
+    }
+    catch (e) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            updatedGraph = e.partialProjectGraph;
+            error = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    const updatedBuilder = new project_graph_builder_1.ProjectGraphBuilder(updatedGraph, ctx.fileMap.projectFileMap);
+    for (const proj of Object.keys(cachedFileData.projectFileMap)) {
+        for (const f of ctx.fileMap.projectFileMap[proj] || []) {
+            const cached = cachedFileData.projectFileMap[proj][f.file];
+            if (cached && cached.deps) {
+                f.deps = [...cached.deps];
+            }
+        }
+    }
+    for (const file of ctx.fileMap.nonProjectFiles) {
+        const cached = cachedFileData.nonProjectFiles[file.file];
+        if (cached?.deps) {
+            file.deps = [...cached.deps];
+        }
+    }
+    (0, implicit_project_dependencies_1.applyImplicitDependencies)(ctx.projects, updatedBuilder);
+    const finalGraph = updatedBuilder.getUpdatedProjectGraph();
+    if (!error) {
+        return finalGraph;
+    }
+    else {
+        throw new error_types_1.AggregateProjectGraphError(error.errors, finalGraph);
+    }
+}
+function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess) {
+    return {
+        nxJsonConfiguration: nxJson,
+        projects,
+        externalNodes,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+        fileMap,
+        filesToProcess,
+    };
+}
+async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins, sourceMap) {
+    let graph = initProjectGraph;
+    const errors = [];
+    const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
+    const createDependencyPlugins = plugins.filter((plugin) => plugin.createDependencies);
+    perf_hooks_1.performance.mark('createDependencies:start');
+    let spinner;
+    const inProgressPlugins = new Set(createDependencyPlugins.map((plugin) => plugin.name));
+    const getSpinnerText = () => spinner
+        ? (0, plugin_progress_text_1.formatPluginProgressText)('Creating project graph dependencies', inProgressPlugins)
+        : '';
+    spinner = new delayed_spinner_1.DelayedSpinner(getSpinnerText(), {
+        progressTopic: progress_topics_1.ProgressTopics.GraphConstruction,
+    });
+    await Promise.all(createDependencyPlugins.map(async (plugin) => {
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
+        try {
+            const dependencies = await plugin
+                .createDependencies({
+                ...context,
+            })
+                .finally(() => {
+                inProgressPlugins.delete(plugin.name);
+                spinner.setMessage(getSpinnerText());
+            });
+            for (const dep of dependencies) {
+                builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
+            }
+        }
+        catch (cause) {
+            errors.push(new error_types_1.ProcessDependenciesError(plugin.name, {
+                cause,
+            }));
+        }
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - end`);
+        perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, {
+            start: `${plugin.name}:createDependencies - start`,
+            end: `${plugin.name}:createDependencies - end`,
+            detail: { track: true },
+        });
+    }));
+    perf_hooks_1.performance.mark('createDependencies:end');
+    perf_hooks_1.performance.measure(`createDependencies`, `createDependencies:start`, `createDependencies:end`);
+    spinner?.cleanup();
+    const graphWithDeps = builder.getUpdatedProjectGraph();
+    const { errors: metadataErrors, graph: updatedGraph } = await applyProjectMetadata(graphWithDeps, plugins, {
+        nxJsonConfiguration: context.nxJsonConfiguration,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    }, sourceMap);
+    errors.push(...metadataErrors);
+    if (errors.length > 0) {
+        throw new error_types_1.AggregateProjectGraphError(errors, updatedGraph);
+    }
+    return updatedGraph;
+}
+function readRootTsConfig() {
+    try {
+        const tsConfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (tsConfigPath) {
+            return (0, fileutils_1.readJsonFile)(tsConfigPath, { expectComments: true });
+        }
+    }
+    catch (e) {
+        return {};
+    }
+}
+async function applyProjectMetadata(graph, plugins, context, sourceMap) {
+    const results = [];
+    const errors = [];
+    perf_hooks_1.performance.mark('createMetadata:start');
+    let spinner;
+    const createMetadataPlugins = plugins.filter((plugin) => plugin.createMetadata);
+    const inProgressPlugins = new Set(createMetadataPlugins.map((p) => p.name));
+    const getSpinnerText = () => spinner
+        ? (0, plugin_progress_text_1.formatPluginProgressText)('Creating project metadata', inProgressPlugins)
+        : '';
+    spinner = createMetadataPlugins.length
+        ? new delayed_spinner_1.DelayedSpinner(getSpinnerText(), {
+            progressTopic: progress_topics_1.ProgressTopics.GraphConstruction,
+        })
+        : undefined;
+    const promises = createMetadataPlugins.map(async (plugin) => {
+        perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
+        try {
+            const metadata = await plugin.createMetadata(graph, context);
+            results.push({ metadata, pluginName: plugin.name });
+        }
+        catch (e) {
+            errors.push(new error_types_1.CreateMetadataError(e, plugin.name));
+        }
+        finally {
+            inProgressPlugins.delete(plugin.name);
+            spinner.setMessage(getSpinnerText());
+            perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - end`);
+            perf_hooks_1.performance.measure(`${plugin.name}:createMetadata`, `${plugin.name}:createMetadata - start`, `${plugin.name}:createMetadata - end`);
+        }
+    });
+    await Promise.all(promises);
+    spinner?.cleanup();
+    for (const { metadata: projectsMetadata, pluginName } of results) {
+        for (const project in projectsMetadata) {
+            const projectConfiguration = graph.nodes[project]?.data;
+            if (projectConfiguration) {
+                projectConfiguration.metadata = (0, target_merging_1.mergeMetadata)(sourceMap[project], [null, pluginName], 'metadata', projectsMetadata[project].metadata, projectConfiguration.metadata);
+            }
+        }
+    }
+    perf_hooks_1.performance.mark('createMetadata:end');
+    perf_hooks_1.performance.measure(`createMetadata`, `createMetadata:start`, `createMetadata:end`);
+    return { errors, graph };
+}
+function hashExternalNodes(externalNodes) {
+    return (0, file_hasher_1.hashObject)(Object.entries(externalNodes).reduce((acc, [name, node]) => {
+        acc[name] = node.data.version;
+        return acc;
+    }, {}));
+}

package/dist/src/project-graph/error-types.d.ts

@@ -0,0 +1,140 @@
+import { ConfigurationResult } from './utils/project-configuration-utils';
+import type { ConfigurationSourceMaps } from './utils/project-configuration/source-maps';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { ProjectGraph } from '../config/project-graph';
+import { CreateNodesFunctionV2 } from './plugins/public-api';
+export type ProjectGraphErrorTypes = AggregateCreateNodesError | MergeNodesError | CreateMetadataError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | WorkspaceValidityError;
+export declare class StaleProjectGraphCacheError extends Error {
+    constructor();
+}
+export declare class ProjectGraphError extends Error {
+    #private;
+    private readonly errors;
+    constructor(errors: Array<ProjectGraphErrorTypes>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps | null);
+    /**
+     * 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: DaemonProjectGraphError): ProjectGraphError;
+    /**
+     * 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(): ProjectGraph;
+    getPartialSourcemaps(): ConfigurationSourceMaps;
+    getErrors(): ProjectGraphErrorTypes[];
+}
+export declare class MultipleProjectsWithSameNameError extends Error {
+    conflicts: Map<string, string[]>;
+    projects: Record<string, ProjectConfiguration>;
+    constructor(conflicts: Map<string, string[]>, projects: Record<string, ProjectConfiguration>);
+}
+export declare class ProjectWithExistingNameError extends Error {
+    projectName: string;
+    projectRoot: string;
+    constructor(projectName: string, projectRoot: string);
+}
+export declare function isProjectWithExistingNameError(e: unknown): e is ProjectWithExistingNameError;
+export declare function isMultipleProjectsWithSameNameError(e: unknown): e is MultipleProjectsWithSameNameError;
+export declare class ProjectsWithNoNameError extends Error {
+    projectRoots: string[];
+    projects: Record<string, ProjectConfiguration>;
+    constructor(projectRoots: string[], projects: Record<string, ProjectConfiguration>);
+}
+export declare function isProjectsWithNoNameError(e: unknown): e is ProjectsWithNoNameError;
+export declare class ProjectWithNoNameError extends Error {
+    projectRoot: string;
+    constructor(projectRoot: string);
+}
+export declare function isProjectWithNoNameError(e: unknown): e is ProjectWithNoNameError;
+export declare class ProjectConfigurationsError extends Error {
+    readonly errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError>;
+    readonly partialProjectConfigurationsResult: ConfigurationResult;
+    constructor(errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError>, partialProjectConfigurationsResult: ConfigurationResult);
+}
+export declare function isProjectConfigurationsError(e: unknown): e is ProjectConfigurationsError;
+/**
+ * This error should be thrown when a `createNodesV2` function hits a recoverable error.
+ * It allows Nx to recieve partial results and continue processing for better UX.
+ */
+export declare class AggregateCreateNodesError extends Error {
+    readonly errors: Array<[file: string | null, error: Error]>;
+    readonly partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>;
+    pluginIndex: number | undefined;
+    /**
+     * Throwing this error from a `createNodesV2` function will allow Nx to continue processing and recieve partial results from your plugin.
+     * @example
+     * export async function createNodesV2(
+     *  files: string[],
+     * ) {
+     *   const partialResults = [];
+     *   const errors = [];
+     *   await Promise.all(files.map(async (file) => {
+     *     try {
+     *        const result = await createNodes(file);
+     *        partialResults.push(result);
+     *     } catch (e) {
+     *        errors.push([file, e]);
+     *     }
+     *   }));
+     *  if (errors.length > 0) {
+     *     throw new AggregateCreateNodesError(errors, partialResults);
+     *   }
+     *   return partialResults;
+     * }
+     *
+     * @param errors An array of tuples that represent errors encountered when processing a given file. An example entry might look like ['path/to/project.json', [Error: 'Invalid JSON. Unexpected token 'a' in JSON at position 0]]
+     * @param partialResults The partial results of the `createNodesV2` function. This should be the results for each file that didn't encounter an issue.
+     */
+    constructor(errors: Array<[file: string | null, error: Error]>, partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>);
+}
+export declare function formatAggregateCreateNodesError(error: AggregateCreateNodesError, pluginName: string): void;
+export declare class MergeNodesError extends Error {
+    file: string;
+    pluginName: string;
+    pluginIndex: number;
+    constructor({ file, pluginName, error, pluginIndex, }: {
+        file: string;
+        pluginName: string;
+        error: Error;
+        pluginIndex?: number;
+    });
+}
+export declare class CreateMetadataError extends Error {
+    readonly error: Error;
+    readonly plugin: string;
+    constructor(error: Error, plugin: string);
+}
+export declare class ProcessDependenciesError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class WorkspaceValidityError extends Error {
+    message: string;
+    constructor(message: string);
+    toString(): string;
+}
+export declare function isWorkspaceValidityError(e: unknown): e is WorkspaceValidityError;
+export declare class AggregateProjectGraphError extends Error {
+    readonly errors: Array<CreateMetadataError | ProcessDependenciesError | WorkspaceValidityError>;
+    readonly partialProjectGraph: ProjectGraph;
+    constructor(errors: Array<CreateMetadataError | ProcessDependenciesError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph);
+}
+export declare function isAggregateProjectGraphError(e: unknown): e is AggregateProjectGraphError;
+export declare function isCreateMetadataError(e: unknown): e is CreateMetadataError;
+export declare function isAggregateCreateNodesError(e: unknown): e is AggregateCreateNodesError;
+export declare function isMergeNodesError(e: unknown): e is MergeNodesError;
+export declare class DaemonProjectGraphError extends Error {
+    errors: any[];
+    readonly projectGraph: ProjectGraph;
+    readonly sourceMaps: ConfigurationSourceMaps;
+    constructor(errors: any[], projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps);
+}
+export declare class LoadPluginError extends Error {
+    plugin: string;
+    constructor(plugin: string, cause: Error);
+}