@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,379 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectGraphBuilder = void 0;
+exports.validateDependency = validateDependency;
+/**
+ * Builder for adding nodes and dependencies to a {@link ProjectGraph}
+ */
+const project_graph_1 = require("../config/project-graph");
+const build_project_graph_1 = require("./build-project-graph");
+/**
+ * A class which builds up a project graph
+ * @deprecated The {@link ProjectGraphProcessor} has been deprecated. Use a {@link CreateNodes} and/or a {@link CreateDependencies} instead. This will be removed in Nx 20.
+ */
+class ProjectGraphBuilder {
+    constructor(graph, projectFileMap, nonProjectFiles) {
+        this.removedEdges = {};
+        if (!projectFileMap || !nonProjectFiles) {
+            const fileMap = (0, build_project_graph_1.getFileMap)().fileMap;
+            projectFileMap ??= fileMap.projectFileMap;
+            nonProjectFiles ??= fileMap.nonProjectFiles;
+        }
+        if (graph) {
+            this.graph = graph;
+            this.projectFileMap = projectFileMap;
+            this.nonProjectFiles = nonProjectFiles;
+        }
+        else {
+            this.graph = {
+                nodes: {},
+                externalNodes: {},
+                dependencies: {},
+            };
+            this.projectFileMap = projectFileMap || {};
+            this.nonProjectFiles = nonProjectFiles || [];
+        }
+    }
+    /**
+     * Merges the nodes and dependencies of p into the built project graph.
+     */
+    mergeProjectGraph(p) {
+        this.graph.nodes = { ...this.graph.nodes, ...p.nodes };
+        this.graph.externalNodes = {
+            ...this.graph.externalNodes,
+            ...p.externalNodes,
+        };
+        this.graph.dependencies = { ...this.graph.dependencies, ...p.dependencies };
+    }
+    /**
+     * Adds a project node to the project graph
+     */
+    addNode(node) {
+        // Check if project with the same name already exists
+        if (this.graph.nodes[node.name]) {
+            // Throw if existing project is of a different type
+            if (this.graph.nodes[node.name].type !== node.type) {
+                throw new Error(`Multiple projects are named "${node.name}". One is of type "${node.type}" and the other is of type "${this.graph.nodes[node.name].type}". Please resolve the conflicting project names.`);
+            }
+        }
+        this.graph.nodes[node.name] = node;
+    }
+    /**
+     * Removes a node and all of its dependency edges from the graph
+     */
+    removeNode(name) {
+        if (!this.graph.nodes[name] && !this.graph.externalNodes[name]) {
+            throw new Error(`There is no node named: "${name}"`);
+        }
+        this.removeDependenciesWithNode(name);
+        if (this.graph.nodes[name]) {
+            delete this.graph.nodes[name];
+        }
+        else {
+            delete this.graph.externalNodes[name];
+        }
+    }
+    /**
+     * Adds a external node to the project graph
+     */
+    addExternalNode(node) {
+        // Check if project with the same name already exists
+        if (this.graph.externalNodes[node.name]) {
+            throw new Error(`Multiple projects are named "${node.name}". One has version "${node.data.version}" and the other has version "${this.graph.externalNodes[node.name].data.version}". Please resolve the conflicting package names.`);
+        }
+        this.graph.externalNodes[node.name] = node;
+    }
+    /**
+     * Adds static dependency from source project to target project
+     */
+    addStaticDependency(sourceProjectName, targetProjectName, sourceProjectFile) {
+        this.addDependency(sourceProjectName, targetProjectName, project_graph_1.DependencyType.static, sourceProjectFile);
+    }
+    /**
+     * Adds dynamic dependency from source project to target project
+     */
+    addDynamicDependency(sourceProjectName, targetProjectName, sourceProjectFile) {
+        this.addDependency(sourceProjectName, targetProjectName, project_graph_1.DependencyType.dynamic, sourceProjectFile);
+    }
+    /**
+     * Adds implicit dependency from source project to target project
+     */
+    addImplicitDependency(sourceProjectName, targetProjectName) {
+        this.addDependency(sourceProjectName, targetProjectName, project_graph_1.DependencyType.implicit);
+    }
+    /**
+     * Removes a dependency from source project to target project
+     */
+    removeDependency(sourceProjectName, targetProjectName) {
+        if (sourceProjectName === targetProjectName) {
+            return;
+        }
+        if (!this.graph.nodes[sourceProjectName]) {
+            throw new Error(`Source project does not exist: ${sourceProjectName}`);
+        }
+        if (!this.graph.nodes[targetProjectName] &&
+            !this.graph.externalNodes[targetProjectName]) {
+            throw new Error(`Target project does not exist: ${targetProjectName}`);
+        }
+        // this.graph.dependencies[sourceProjectName] = this.graph.dependencies[
+        //   sourceProjectName
+        // ].filter((d) => d.target !== targetProjectName);
+        if (!this.removedEdges[sourceProjectName]) {
+            this.removedEdges[sourceProjectName] = new Set();
+        }
+        this.removedEdges[sourceProjectName].add(targetProjectName);
+    }
+    /**
+     * Add an explicit dependency from a file in source project to target project
+     * @deprecated this method will be removed in v17. Use {@link addStaticDependency} or {@link addDynamicDependency} instead
+     */
+    addExplicitDependency(sourceProjectName, sourceProjectFile, targetProjectName) {
+        this.addStaticDependency(sourceProjectName, targetProjectName, sourceProjectFile);
+    }
+    /**
+     * Set version of the project graph
+     */
+    setVersion(version) {
+        this.graph.version = version;
+    }
+    getUpdatedProjectGraph() {
+        for (const sourceProject of Object.keys(this.graph.nodes)) {
+            const alreadySetTargetProjects = this.calculateAlreadySetTargetDeps(sourceProject);
+            this.graph.dependencies[sourceProject] = [
+                ...alreadySetTargetProjects.values(),
+            ].flatMap((depsMap) => [...depsMap.values()]);
+            const fileDeps = this.calculateTargetDepsFromFiles(sourceProject);
+            for (const [targetProject, types] of fileDeps.entries()) {
+                // only add known nodes
+                if (!this.graph.nodes[targetProject] &&
+                    !this.graph.externalNodes[targetProject]) {
+                    continue;
+                }
+                for (const type of types.values()) {
+                    if (!alreadySetTargetProjects.has(targetProject) ||
+                        !alreadySetTargetProjects.get(targetProject).has(type)) {
+                        if (!this.removedEdges[sourceProject] ||
+                            !this.removedEdges[sourceProject].has(targetProject)) {
+                            this.graph.dependencies[sourceProject].push({
+                                source: sourceProject,
+                                target: targetProject,
+                                type,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        for (const file of this.nonProjectFiles) {
+            if (file.deps) {
+                for (const dep of file.deps) {
+                    if (!Array.isArray(dep)) {
+                        throw new Error('Cached data on non project files should be a tuple');
+                    }
+                    const [source, target, type] = dep;
+                    if (!source || !target || !type) {
+                        throw new Error('Cached dependencies for non project files should be a tuple of length 3.');
+                    }
+                    this.graph.dependencies[source].push({
+                        source,
+                        target,
+                        type,
+                    });
+                }
+            }
+        }
+        return this.graph;
+    }
+    addDependency(source, target, type, sourceFile) {
+        if (source === target) {
+            return;
+        }
+        validateDependency({
+            source,
+            target,
+            type,
+            sourceFile,
+        }, {
+            externalNodes: this.graph.externalNodes,
+            fileMap: {
+                projectFileMap: this.projectFileMap,
+                nonProjectFiles: this.nonProjectFiles,
+            },
+            // the validators only really care about the keys on this.
+            projects: this.graph.nodes,
+            filesToProcess: null,
+            nxJsonConfiguration: null,
+            workspaceRoot: null,
+        });
+        if (!this.graph.dependencies[source]) {
+            this.graph.dependencies[source] = [];
+        }
+        const isDuplicate = !!this.graph.dependencies[source].find((d) => d.target === target && d.type === type);
+        if (sourceFile) {
+            let fileData = getProjectFileData(source, sourceFile, this.projectFileMap);
+            const isProjectFileData = !!fileData;
+            fileData ??= getNonProjectFileData(sourceFile, this.nonProjectFiles);
+            if (!fileData.deps) {
+                fileData.deps = [];
+            }
+            if (!fileData.deps.find((t) => (0, project_graph_1.fileDataDepTarget)(t) === target && (0, project_graph_1.fileDataDepType)(t) === type)) {
+                const dep = isProjectFileData
+                    ? type === 'static'
+                        ? target
+                        : [target, type]
+                    : [source, target, type];
+                fileData.deps.push(dep);
+            }
+        }
+        else if (!isDuplicate) {
+            // only add to dependencies section if the source file is not specified
+            // and not already added
+            this.graph.dependencies[source].push({
+                source: source,
+                target: target,
+                type,
+            });
+        }
+    }
+    removeDependenciesWithNode(name) {
+        // remove all source dependencies
+        delete this.graph.dependencies[name];
+        // remove all target dependencies
+        for (const dependencies of Object.values(this.graph.dependencies)) {
+            for (const [index, { source, target }] of dependencies.entries()) {
+                if (target === name) {
+                    const deps = this.graph.dependencies[source];
+                    this.graph.dependencies[source] = [
+                        ...deps.slice(0, index),
+                        ...deps.slice(index + 1),
+                    ];
+                    if (this.graph.dependencies[source].length === 0) {
+                        delete this.graph.dependencies[source];
+                    }
+                }
+            }
+        }
+    }
+    calculateTargetDepsFromFiles(sourceProject) {
+        const fileDeps = new Map();
+        const files = this.projectFileMap[sourceProject] || [];
+        if (!files) {
+            return fileDeps;
+        }
+        for (let f of files) {
+            if (f.deps) {
+                for (let d of f.deps) {
+                    const target = (0, project_graph_1.fileDataDepTarget)(d);
+                    if (!fileDeps.has(target)) {
+                        fileDeps.set(target, new Set([(0, project_graph_1.fileDataDepType)(d)]));
+                    }
+                    else {
+                        fileDeps.get(target).add((0, project_graph_1.fileDataDepType)(d));
+                    }
+                }
+            }
+        }
+        return fileDeps;
+    }
+    calculateAlreadySetTargetDeps(sourceProject) {
+        const alreadySetTargetProjects = new Map();
+        if (this.graph.dependencies[sourceProject]) {
+            const removed = this.removedEdges[sourceProject];
+            for (const d of this.graph.dependencies[sourceProject]) {
+                // static and dynamic dependencies of internal projects
+                // will be rebuilt based on the file dependencies
+                // we only need to keep the implicit dependencies
+                if (d.type === project_graph_1.DependencyType.implicit && !removed?.has(d.target)) {
+                    if (!alreadySetTargetProjects.has(d.target)) {
+                        alreadySetTargetProjects.set(d.target, new Map([[d.type, d]]));
+                    }
+                    else {
+                        alreadySetTargetProjects.get(d.target).set(d.type, d);
+                    }
+                }
+            }
+        }
+        return alreadySetTargetProjects;
+    }
+}
+exports.ProjectGraphBuilder = ProjectGraphBuilder;
+/**
+ * A function to validate dependencies in a {@link CreateDependencies} function
+ * @throws If the dependency is invalid.
+ */
+function validateDependency(dependency, ctx) {
+    if (dependency.type === project_graph_1.DependencyType.implicit) {
+        validateImplicitDependency(dependency, ctx);
+    }
+    else if (dependency.type === project_graph_1.DependencyType.dynamic) {
+        validateDynamicDependency(dependency, ctx);
+    }
+    else if (dependency.type === project_graph_1.DependencyType.static) {
+        validateStaticDependency(dependency, ctx);
+    }
+    validateCommonDependencyRules(dependency, ctx);
+}
+function validateCommonDependencyRules(d, { externalNodes, projects, fileMap }) {
+    if (!projects[d.source] && !externalNodes[d.source]) {
+        throw new Error(`Source project does not exist: ${d.source}`);
+    }
+    if (!projects[d.target] &&
+        !externalNodes[d.target] &&
+        !('sourceFile' in d && d.sourceFile)) {
+        throw new Error(`Target project does not exist: ${d.target}`);
+    }
+    if (externalNodes[d.source] && projects[d.target]) {
+        throw new Error(`External projects can't depend on internal projects`);
+    }
+    if ('sourceFile' in d && d.sourceFile) {
+        if (projects[d.source]) {
+            // Throws if source file is not a valid file within the source project.
+            // We can pass empty array for all workspace files here, since its not checked by the impl.
+            // We need all workspace files in here for the TODO comment though, so lets figure that out.
+            getFileData(d.source, d.sourceFile, projects, externalNodes, fileMap.projectFileMap, fileMap.nonProjectFiles);
+        }
+    }
+}
+function validateImplicitDependency(d, { externalNodes }) {
+    if (externalNodes[d.source]) {
+        throw new Error(`External projects can't have "implicit" dependencies`);
+    }
+}
+function validateDynamicDependency(d, { externalNodes }) {
+    if (externalNodes[d.source]) {
+        throw new Error(`External projects can't have "dynamic" dependencies`);
+    }
+    // dynamic dependency is always bound to a file
+    if (!d.sourceFile) {
+        throw new Error(`Source project file is required for "dynamic" dependencies`);
+    }
+}
+function validateStaticDependency(d, { projects }) {
+    // internal nodes must provide sourceProjectFile when creating static dependency
+    // externalNodes do not have sourceProjectFile
+    if (projects[d.source] && !d.sourceFile) {
+        throw new Error(`Source project file is required`);
+    }
+}
+function getProjectFileData(source, sourceFile, fileMap) {
+    let fileData = (fileMap[source] || []).find((f) => f.file === sourceFile);
+    if (fileData) {
+        return fileData;
+    }
+}
+function getNonProjectFileData(sourceFile, files) {
+    const fileData = files.find((f) => f.file === sourceFile);
+    if (!fileData) {
+        throw new Error(`Source file "${sourceFile}" does not exist in the workspace.`);
+    }
+    return fileData;
+}
+function getFileData(source, sourceFile, projects, externalNodes, fileMap, nonProjectFiles) {
+    const sourceProject = projects[source];
+    const matchingExternalNode = externalNodes[source];
+    if (!sourceProject && !matchingExternalNode) {
+        throw new Error(`Source project is not a project node: ${sourceProject}`);
+    }
+    return (getProjectFileData(source, sourceFile, fileMap) ??
+        getNonProjectFileData(sourceFile, nonProjectFiles));
+}

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

@@ -0,0 +1,51 @@
+import { ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+/**
+ * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ * @throws {Error} if there is no cached ProjectGraph to read from
+ */
+export declare function readCachedProjectGraph(): ProjectGraph;
+export declare function readCachedProjectConfiguration(projectName: string): ProjectConfiguration;
+/**
+ * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}
+ */
+export declare function readProjectsConfigurationFromProjectGraph(projectGraph: ProjectGraph): ProjectsConfigurations;
+export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
+    projectGraph: ProjectGraph;
+    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
+}>;
+export declare function handleProjectGraphError(opts: {
+    exitOnError: boolean;
+}, e: any): void;
+/**
+ * Computes and returns a ProjectGraph.
+ *
+ * Nx will compute the graph either in a daemon process or in the current process.
+ *
+ * Nx will compute it in the current process if:
+ * * The process is running in CI (CI env variable is to true or other common variables used by CI providers are set).
+ * * It is running in the docker container.
+ * * The daemon process is disabled because of the previous error when starting the daemon.
+ * * `NX_DAEMON` is set to `false`.
+ * * `useDaemonProcess` is set to false in the options of the tasks runner inside `nx.json`
+ *
+ * `NX_DAEMON` env variable takes precedence:
+ * * If it is set to true, the daemon will always be used.
+ * * If it is set to false, the graph will always be computed in the current process.
+ *
+ * Tip: If you want to debug project graph creation, run your command with NX_DAEMON=false.
+ *
+ * Nx uses two layers of caching: the information about explicit dependencies stored on the disk and the information
+ * stored in the daemon process. To reset both run: `nx reset`.
+ */
+export declare function createProjectGraphAsync(opts?: {
+    exitOnError: boolean;
+    resetDaemonClient?: boolean;
+}): Promise<ProjectGraph>;
+export declare function createProjectGraphAndSourceMapsAsync(opts?: {
+    exitOnError: boolean;
+    resetDaemonClient?: boolean;
+}): Promise<{
+    projectGraph: ProjectGraph;
+    sourceMaps: import("./utils/project-configuration-utils").ConfigurationSourceMaps;
+}>;

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCachedProjectGraph = readCachedProjectGraph;
+exports.readCachedProjectConfiguration = readCachedProjectConfiguration;
+exports.readProjectsConfigurationFromProjectGraph = readProjectsConfigurationFromProjectGraph;
+exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;
+exports.handleProjectGraphError = handleProjectGraphError;
+exports.createProjectGraphAsync = createProjectGraphAsync;
+exports.createProjectGraphAndSourceMapsAsync = createProjectGraphAndSourceMapsAsync;
+const perf_hooks_1 = require("perf_hooks");
+const nx_json_1 = require("../config/nx-json");
+const client_1 = require("../daemon/client/client");
+const tmp_dir_1 = require("../daemon/tmp-dir");
+const fileutils_1 = require("../utils/fileutils");
+const output_1 = require("../utils/output");
+const strip_indents_1 = require("../utils/strip-indents");
+const workspace_root_1 = require("../utils/workspace-root");
+const build_project_graph_1 = require("./build-project-graph");
+const error_types_1 = require("./error-types");
+const nx_deps_cache_1 = require("./nx-deps-cache");
+const internal_api_1 = require("./plugins/internal-api");
+const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
+/**
+ * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ * @throws {Error} if there is no cached ProjectGraph to read from
+ */
+function readCachedProjectGraph() {
+    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)();
+    if (!projectGraphCache) {
+        const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
+            ? (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 Monorepos · Fast CI'.
+      `
+            : '';
+        throw new Error((0, strip_indents_1.stripIndents) `
+      [readCachedProjectGraph] ERROR: No cached ProjectGraph is available.
+
+      If you are leveraging \`readCachedProjectGraph()\` directly then you will need to refactor your usage to first ensure that
+      the ProjectGraph is created by calling \`await createProjectGraphAsync()\` somewhere before attempting to read the data.
+
+      If you encounter this error as part of running standard \`nx\` commands then please open an issue on https://github.com/nrwl/nx
+
+      ${angularSpecificError}
+    `);
+    }
+    return projectGraphCache;
+}
+function readCachedProjectConfiguration(projectName) {
+    const graph = readCachedProjectGraph();
+    const node = graph.nodes[projectName];
+    try {
+        return node.data;
+    }
+    catch (e) {
+        throw new Error(`Cannot find project: '${projectName}' in your workspace.`);
+    }
+}
+/**
+ * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}
+ */
+function readProjectsConfigurationFromProjectGraph(projectGraph) {
+    return {
+        projects: Object.fromEntries(Object.entries(projectGraph.nodes).map(([project, { data }]) => [
+            project,
+            data,
+        ])),
+        version: 2,
+    };
+}
+async function buildProjectGraphAndSourceMapsWithoutDaemon() {
+    global.NX_GRAPH_CREATION = true;
+    const nxJson = (0, nx_json_1.readNxJson)();
+    perf_hooks_1.performance.mark('retrieve-project-configurations:start');
+    let configurationResult;
+    let projectConfigurationsError;
+    const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson.plugins);
+    try {
+        configurationResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
+    }
+    catch (e) {
+        if (e instanceof error_types_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';
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
+    let projectGraphError;
+    let projectGraphResult;
+    try {
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
+    }
+    catch (e) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
+            projectGraphResult = {
+                projectGraph: e.partialProjectGraph,
+                projectFileMapCache: null,
+            };
+            projectGraphError = e;
+        }
+        else {
+            throw e;
+        }
+    }
+    finally {
+        // When plugins are isolated we don't clean them up during
+        // a single run of the CLI. They are cleaned up when the CLI
+        // process exits. Cleaning them here could cause issues if pending
+        // promises are not resolved.
+        if (process.env.NX_ISOLATE_PLUGINS !== 'true') {
+            cleanup();
+        }
+    }
+    const { projectGraph, projectFileMapCache } = projectGraphResult;
+    perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
+    delete global.NX_GRAPH_CREATION;
+    const errors = [
+        ...(projectConfigurationsError?.errors ?? []),
+        ...(projectGraphError?.errors ?? []),
+    ];
+    if (errors.length > 0) {
+        throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
+    }
+    else {
+        if (cacheEnabled) {
+            (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
+        }
+        return { projectGraph, sourceMaps };
+    }
+}
+function handleProjectGraphError(opts, e) {
+    if (opts.exitOnError) {
+        const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+        if (e instanceof error_types_1.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);
+    }
+    else {
+        throw e;
+    }
+}
+/**
+ * Computes and returns a ProjectGraph.
+ *
+ * Nx will compute the graph either in a daemon process or in the current process.
+ *
+ * Nx will compute it in the current process if:
+ * * The process is running in CI (CI env variable is to true or other common variables used by CI providers are set).
+ * * It is running in the docker container.
+ * * The daemon process is disabled because of the previous error when starting the daemon.
+ * * `NX_DAEMON` is set to `false`.
+ * * `useDaemonProcess` is set to false in the options of the tasks runner inside `nx.json`
+ *
+ * `NX_DAEMON` env variable takes precedence:
+ * * If it is set to true, the daemon will always be used.
+ * * If it is set to false, the graph will always be computed in the current process.
+ *
+ * Tip: If you want to debug project graph creation, run your command with NX_DAEMON=false.
+ *
+ * Nx uses two layers of caching: the information about explicit dependencies stored on the disk and the information
+ * stored in the daemon process. To reset both run: `nx reset`.
+ */
+async function createProjectGraphAsync(opts = {
+    exitOnError: false,
+    resetDaemonClient: false,
+}) {
+    const projectGraphAndSourceMaps = await createProjectGraphAndSourceMapsAsync(opts);
+    return projectGraphAndSourceMaps.projectGraph;
+}
+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 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;
+        }
+        catch (e) {
+            handleProjectGraphError(opts, e);
+        }
+    }
+    else {
+        try {
+            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 projectGraphAndSourceMaps;
+        }
+        catch (e) {
+            if (e.message && e.message.indexOf('inotify_add_watch') > -1) {
+                // common errors with the daemon due to OS settings (cannot watch all the files available)
+                output_1.output.note({
+                    title: `Unable to start Nx Daemon due to the limited amount of inotify watches, continuing without the daemon.`,
+                    bodyLines: [
+                        'For more information read: https://askubuntu.com/questions/1088272/inotify-add-watch-failed-no-space-left-on-device',
+                        'Nx Daemon is going to be disabled until you run "nx reset".',
+                    ],
+                });
+                (0, tmp_dir_1.markDaemonAsDisabled)();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            if (e.internalDaemonError) {
+                const errorLogFile = (0, tmp_dir_1.writeDaemonLogs)(e.message);
+                output_1.output.warn({
+                    title: `Nx Daemon was not able to compute the project graph.`,
+                    bodyLines: [
+                        `Log file with the error: ${errorLogFile}`,
+                        `Please file an issue at https://github.com/nrwl/nx`,
+                        'Nx Daemon is going to be disabled until you run "nx reset".',
+                    ],
+                });
+                (0, tmp_dir_1.markDaemonAsDisabled)();
+                return buildProjectGraphAndSourceMapsWithoutDaemon();
+            }
+            handleProjectGraphError(opts, e);
+        }
+        finally {
+            if (opts.resetDaemonClient) {
+                client_1.daemonClient.reset();
+            }
+        }
+    }
+}