@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,305 @@
+"use strict";
+var _ProjectGraphError_errors, _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.AggregateProjectGraphError = exports.ProcessProjectGraphError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.ProjectConfigurationsError = exports.ProjectWithNoNameError = exports.ProjectsWithNoNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = void 0;
+exports.isProjectWithExistingNameError = isProjectWithExistingNameError;
+exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameError;
+exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
+exports.isProjectWithNoNameError = isProjectWithNoNameError;
+exports.isProjectConfigurationsError = isProjectConfigurationsError;
+exports.isWorkspaceValidityError = isWorkspaceValidityError;
+exports.isAggregateProjectGraphError = isAggregateProjectGraphError;
+exports.isCreateMetadataError = isCreateMetadataError;
+exports.isAggregateCreateNodesError = isAggregateCreateNodesError;
+exports.isMergeNodesError = isMergeNodesError;
+const tslib_1 = require("tslib");
+class ProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph, partialSourceMaps) {
+        super(`Failed to process project graph. Run "nx reset" to fix this. Please report the issue if you keep seeing it.`);
+        _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) => indentString(formatErrorStackAndCause(error), 2))
+            .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.ProjectGraphError = ProjectGraphError;
+_ProjectGraphError_errors = new WeakMap(), _ProjectGraphError_partialProjectGraph = new WeakMap(), _ProjectGraphError_partialSourceMaps = new WeakMap();
+class MultipleProjectsWithSameNameError extends Error {
+    constructor(conflicts, projects) {
+        super([
+            `The following projects are defined in multiple locations:`,
+            ...Array.from(conflicts.entries()).map(([project, roots]) => [`- ${project}: `, ...roots.map((r) => `  - ${r}`)].join('\n')),
+            '',
+            "To fix this, set a unique name for each project in a project.json inside the project's root. If the project does not currently have a project.json, you can create one that contains only a name.",
+        ].join('\n'));
+        this.conflicts = conflicts;
+        this.projects = projects;
+        this.name = this.constructor.name;
+    }
+}
+exports.MultipleProjectsWithSameNameError = MultipleProjectsWithSameNameError;
+class ProjectWithExistingNameError extends Error {
+    constructor(projectName, projectRoot) {
+        super(`The project "${projectName}" is defined in multiple locations.`);
+        this.projectName = projectName;
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithExistingNameError = ProjectWithExistingNameError;
+function isProjectWithExistingNameError(e) {
+    return (e instanceof ProjectWithExistingNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithExistingNameError.name));
+}
+function isMultipleProjectsWithSameNameError(e) {
+    return (e instanceof MultipleProjectsWithSameNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === MultipleProjectsWithSameNameError.name));
+}
+class ProjectsWithNoNameError extends Error {
+    constructor(projectRoots, projects) {
+        super(`The projects in the following directories have no name provided:\n  - ${projectRoots.join('\n  - ')}`);
+        this.projectRoots = projectRoots;
+        this.projects = projects;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectsWithNoNameError = ProjectsWithNoNameError;
+function isProjectsWithNoNameError(e) {
+    return (e instanceof ProjectsWithNoNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectsWithNoNameError.name));
+}
+class ProjectWithNoNameError extends Error {
+    constructor(projectRoot) {
+        super(`The project in ${projectRoot} has no name provided.`);
+        this.projectRoot = projectRoot;
+        this.name = this.constructor.name;
+    }
+}
+exports.ProjectWithNoNameError = ProjectWithNoNameError;
+function isProjectWithNoNameError(e) {
+    return (e instanceof ProjectWithNoNameError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectWithNoNameError.name));
+}
+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;
+function isProjectConfigurationsError(e) {
+    return (e instanceof ProjectConfigurationsError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === ProjectConfigurationsError.name));
+}
+/**
+ * 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.
+ */
+class AggregateCreateNodesError extends Error {
+    /**
+     * 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, partialResults) {
+        super('Failed to create nodes');
+        this.errors = errors;
+        this.partialResults = partialResults;
+        this.name = this.constructor.name;
+        if (
+        // Errors should be an array
+        !Array.isArray(errors) ||
+            !errors.every(
+            // Where every element is a tuple
+            (errorTuple) => Array.isArray(errorTuple) &&
+                // That has a length of 2
+                errorTuple.length === 2)) {
+            throw new Error('AggregateCreateNodesError must be constructed with an array of tuples where the first element is a filename or undefined and the second element is the underlying error.');
+        }
+    }
+}
+exports.AggregateCreateNodesError = AggregateCreateNodesError;
+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${indentString(formatErrorStackAndCause(error), 2)}`;
+    }
+}
+exports.MergeNodesError = MergeNodesError;
+class CreateMetadataError extends Error {
+    constructor(error, plugin) {
+        super(`The "${plugin}" plugin threw an error while creating metadata: ${error.message}`, {
+            cause: error,
+        });
+        this.error = error;
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.CreateMetadataError = CreateMetadataError;
+class ProcessDependenciesError extends Error {
+    constructor(pluginName, { cause }) {
+        super(`The "${pluginName}" plugin threw an error while creating dependencies: ${cause.message}`, {
+            cause,
+        });
+        this.pluginName = pluginName;
+        this.name = this.constructor.name;
+        this.stack = `${this.message}\n  ${cause.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.ProcessDependenciesError = ProcessDependenciesError;
+class WorkspaceValidityError extends Error {
+    constructor(message) {
+        message = `Configuration Error\n${message}`;
+        super(message);
+        this.message = message;
+        this.name = this.constructor.name;
+    }
+}
+exports.WorkspaceValidityError = WorkspaceValidityError;
+function isWorkspaceValidityError(e) {
+    return (e instanceof WorkspaceValidityError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === WorkspaceValidityError.name));
+}
+class ProcessProjectGraphError extends Error {
+    constructor(pluginName, { cause }) {
+        super(`The "${pluginName}" plugin threw an error while processing the project graph:`, {
+            cause,
+        });
+        this.pluginName = pluginName;
+        this.name = this.constructor.name;
+        this.stack = `${this.message}\n${indentString(cause, 2)}`;
+    }
+}
+exports.ProcessProjectGraphError = ProcessProjectGraphError;
+class AggregateProjectGraphError extends Error {
+    constructor(errors, partialProjectGraph) {
+        super('Failed to create project graph. See above for errors');
+        this.errors = errors;
+        this.partialProjectGraph = partialProjectGraph;
+        this.name = this.constructor.name;
+    }
+}
+exports.AggregateProjectGraphError = AggregateProjectGraphError;
+function isAggregateProjectGraphError(e) {
+    return (e instanceof AggregateProjectGraphError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === AggregateProjectGraphError.name));
+}
+function isCreateMetadataError(e) {
+    return (e instanceof CreateMetadataError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === CreateMetadataError.name));
+}
+function isAggregateCreateNodesError(e) {
+    return (e instanceof AggregateCreateNodesError ||
+        (typeof e === 'object' &&
+            'name' in e &&
+            e?.name === AggregateCreateNodesError.name));
+}
+function isMergeNodesError(e) {
+    return (e instanceof MergeNodesError ||
+        (typeof e === 'object' && 'name' in e && e?.name === MergeNodesError.name));
+}
+class DaemonProjectGraphError extends Error {
+    constructor(errors, projectGraph, sourceMaps) {
+        super(`The Daemon Process threw an error while calculating the project graph. Convert this error to a ProjectGraphError to get more information.`);
+        this.errors = errors;
+        this.projectGraph = projectGraph;
+        this.sourceMaps = sourceMaps;
+        this.name = this.constructor.name;
+    }
+}
+exports.DaemonProjectGraphError = DaemonProjectGraphError;
+class LoadPluginError extends Error {
+    constructor(plugin, cause) {
+        super(`Could not load plugin ${plugin}`, {
+            cause,
+        });
+        this.plugin = plugin;
+        this.name = this.constructor.name;
+    }
+}
+exports.LoadPluginError = LoadPluginError;
+function indentString(str, indent) {
+    return (' '.repeat(indent) +
+        str
+            .split('\n')
+            .map((line) => ' '.repeat(indent) + line)
+            .join('\n'));
+}
+function formatErrorStackAndCause(error) {
+    const cause = error.cause && error.cause instanceof Error ? error.cause : null;
+    return (error.stack +
+        (cause
+            ? `\nCaused by: \n${indentString(cause.stack ?? cause.message, 2)}`
+            : ''));
+}

package/src/project-graph/file-map-utils.d.ts

@@ -0,0 +1,15 @@
+import { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { NxWorkspaceFilesExternals } from '../native';
+export interface WorkspaceFileMap {
+    allWorkspaceFiles: FileData[];
+    fileMap: FileMap;
+}
+export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
+export declare function createFileMapUsingProjectGraph(graph: ProjectGraph): Promise<WorkspaceFileMap>;
+export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): WorkspaceFileMap;
+export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): {
+    fileMap: import("../native").FileMap;
+    allWorkspaceFiles: FileData[];
+    rustReferences: NxWorkspaceFilesExternals;
+};

package/src/project-graph/file-map-utils.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectFileMapUsingProjectGraph = createProjectFileMapUsingProjectGraph;
+exports.createFileMapUsingProjectGraph = createFileMapUsingProjectGraph;
+exports.createFileMap = createFileMap;
+exports.updateFileMap = updateFileMap;
+const workspace_context_1 = require("../utils/workspace-context");
+const workspace_root_1 = require("../utils/workspace-root");
+const project_graph_1 = require("./project-graph");
+const build_all_workspace_files_1 = require("./utils/build-all-workspace-files");
+const find_project_for_path_1 = require("./utils/find-project-for-path");
+async function createProjectFileMapUsingProjectGraph(graph) {
+    return (await createFileMapUsingProjectGraph(graph)).fileMap.projectFileMap;
+}
+// TODO: refactor this to pull straight from the rust context instead of creating the file map in JS
+async function createFileMapUsingProjectGraph(graph) {
+    const configs = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph);
+    let files = await (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
+    return createFileMap(configs, files);
+}
+function createFileMap(projectsConfigurations, allWorkspaceFiles) {
+    const projectFileMap = {};
+    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations.projects);
+    const nonProjectFiles = [];
+    for (const projectName of Object.keys(projectsConfigurations.projects)) {
+        projectFileMap[projectName] ??= [];
+    }
+    for (const f of allWorkspaceFiles) {
+        const projectFileMapKey = (0, find_project_for_path_1.findProjectForPath)(f.file, projectRootMappings);
+        if (projectFileMapKey) {
+            const matchingProjectFiles = projectFileMap[projectFileMapKey];
+            if (matchingProjectFiles) {
+                matchingProjectFiles.push(f);
+            }
+        }
+        else {
+            nonProjectFiles.push(f);
+        }
+    }
+    return {
+        allWorkspaceFiles,
+        fileMap: {
+            projectFileMap,
+            nonProjectFiles,
+        },
+    };
+}
+function updateFileMap(projectsConfigurations, rustReferences, updatedFiles, deletedFiles) {
+    const updates = (0, workspace_context_1.updateProjectFiles)(Object.fromEntries((0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations)), rustReferences, updatedFiles, deletedFiles);
+    return {
+        fileMap: updates.fileMap,
+        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(updates.fileMap.projectFileMap, updates.fileMap.nonProjectFiles),
+        rustReferences: updates.externalReferences,
+    };
+}

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

@@ -0,0 +1,30 @@
+import { FileData } from '../config/project-graph';
+import { ProjectsConfigurations } from '../config/workspace-json-project-json';
+import type { NxArgs } from '../utils/command-line-utils';
+export interface Change {
+    type: string;
+}
+export interface FileChange<T extends Change = Change> extends FileData {
+    getChanges: () => T[];
+}
+export declare class WholeFileChange implements Change {
+    type: string;
+}
+export declare class DeletedFileChange implements Change {
+    type: string;
+}
+export declare function isWholeFileChange(change: Change): change is WholeFileChange;
+export declare function isDeletedFileChange(change: Change): change is DeletedFileChange;
+export declare function calculateFileChanges(files: string[], allWorkspaceFiles: FileData[], nxArgs?: NxArgs, readFileAtRevision?: (f: string, r: void | string) => string, ignore?: ReturnType<typeof ignore>): FileChange[];
+export declare const TEN_MEGABYTES: number;
+/**
+ * TODO(v20): Remove this function
+ * @deprecated To get projects use {@link retrieveProjectConfigurations} instead. This will be removed in v20.
+ */
+export declare function readWorkspaceConfig(opts: {
+    format: 'angularCli' | 'nx';
+    path?: string;
+}): ProjectsConfigurations;
+export declare function defaultFileRead(filePath: string): string | null;
+export declare function readPackageJson(): any;
+export { FileData };

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEN_MEGABYTES = exports.DeletedFileChange = exports.WholeFileChange = void 0;
+exports.isWholeFileChange = isWholeFileChange;
+exports.isDeletedFileChange = isDeletedFileChange;
+exports.calculateFileChanges = calculateFileChanges;
+exports.readWorkspaceConfig = readWorkspaceConfig;
+exports.defaultFileRead = defaultFileRead;
+exports.readPackageJson = readPackageJson;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const configuration_1 = require("../config/configuration");
+const workspace_root_1 = require("../utils/workspace-root");
+const fileutils_1 = require("../utils/fileutils");
+const json_diff_1 = require("../utils/json-diff");
+const project_graph_1 = require("./project-graph");
+const angular_json_1 = require("../adapter/angular-json");
+const ignore_1 = require("../utils/ignore");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const package_json_1 = require("../plugins/package-json");
+const workspace_context_1 = require("../utils/workspace-context");
+const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
+class WholeFileChange {
+    constructor() {
+        this.type = 'WholeFileChange';
+    }
+}
+exports.WholeFileChange = WholeFileChange;
+class DeletedFileChange {
+    constructor() {
+        this.type = 'WholeFileDeleted';
+    }
+}
+exports.DeletedFileChange = DeletedFileChange;
+function isWholeFileChange(change) {
+    return change.type === 'WholeFileChange';
+}
+function isDeletedFileChange(change) {
+    return change.type === 'WholeFileDeleted';
+}
+function calculateFileChanges(files, allWorkspaceFiles, nxArgs, readFileAtRevision = defaultReadFileAtRevision, ignore = (0, ignore_1.getIgnoreObject)()) {
+    files = files.filter((f) => !ignore.ignores(f));
+    return files.map((f) => {
+        const ext = (0, path_1.extname)(f);
+        const file = allWorkspaceFiles.find((fileData) => fileData.file == f);
+        const hash = file?.hash;
+        return {
+            file: f,
+            ext,
+            hash,
+            getChanges: () => {
+                if (!(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, f))) {
+                    return [new DeletedFileChange()];
+                }
+                if (!nxArgs) {
+                    return [new WholeFileChange()];
+                }
+                if (nxArgs.files && nxArgs.files.includes(f)) {
+                    return [new WholeFileChange()];
+                }
+                switch (ext) {
+                    case '.json':
+                        try {
+                            const atBase = readFileAtRevision(f, nxArgs.base);
+                            const atHead = readFileAtRevision(f, nxArgs.head);
+                            return (0, json_diff_1.jsonDiff)(JSON.parse(atBase), JSON.parse(atHead));
+                        }
+                        catch (e) {
+                            return [new WholeFileChange()];
+                        }
+                    default:
+                        return [new WholeFileChange()];
+                }
+            },
+        };
+    });
+}
+exports.TEN_MEGABYTES = 1024 * 10000;
+function defaultReadFileAtRevision(file, revision) {
+    try {
+        const fileFullPath = `${workspace_root_1.workspaceRoot}${path_1.sep}${file}`;
+        const gitRepositoryPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel')
+            .toString()
+            .trim();
+        const filePathInGitRepository = (0, path_1.relative)(gitRepositoryPath, fileFullPath)
+            .split(path_1.sep)
+            .join('/');
+        return !revision
+            ? (0, fs_1.readFileSync)(file, 'utf-8')
+            : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
+                maxBuffer: exports.TEN_MEGABYTES,
+                stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
+            })
+                .toString()
+                .trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * TODO(v20): Remove this function
+ * @deprecated To get projects use {@link retrieveProjectConfigurations} instead. This will be removed in v20.
+ */
+function readWorkspaceConfig(opts) {
+    let configuration = null;
+    const root = opts.path || process.cwd();
+    const nxJson = (0, configuration_1.readNxJson)(root);
+    try {
+        const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+        configuration = {
+            ...nxJson,
+            ...(0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
+        };
+    }
+    catch {
+        configuration = {
+            version: 2,
+            projects: getProjectsSync(root, nxJson),
+        };
+    }
+    if (opts.format === 'angularCli') {
+        return (0, angular_json_1.toOldFormat)(configuration);
+    }
+    else {
+        return configuration;
+    }
+}
+function defaultFileRead(filePath) {
+    return (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, filePath), 'utf-8');
+}
+function readPackageJson() {
+    try {
+        return (0, fileutils_1.readJsonFile)(`${workspace_root_1.workspaceRoot}/package.json`);
+    }
+    catch {
+        return {}; // if package.json doesn't exist
+    }
+}
+/**
+ * TODO(v20): Remove this function.
+ */
+function getProjectsSync(root, nxJson) {
+    /**
+     * We can't update projects that come from plugins anyways, so we are going
+     * to ignore them for now. Plugins should add their own add/create/update methods
+     * if they would like to use devkit to update inferred projects.
+     */
+    const patterns = [
+        '**/project.json',
+        'project.json',
+        ...(0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(root, fileutils_1.readJsonFile),
+    ];
+    const projectFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(root, patterns);
+    const rootMap = {};
+    for (const projectFile of projectFiles) {
+        if ((0, path_1.basename)(projectFile) === 'project.json') {
+            const json = (0, fileutils_1.readJsonFile)(projectFile);
+            const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
+            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
+        }
+        else if ((0, path_1.basename)(projectFile) === 'package.json') {
+            const packageJson = (0, fileutils_1.readJsonFile)(projectFile);
+            const config = (0, package_json_1.buildProjectConfigurationFromPackageJson)(packageJson, root, projectFile, nxJson);
+            if (!rootMap[config.root]) {
+                (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
+                // Inferred targets, tags, etc don't show up when running generators
+                // This is to help avoid running into issues when trying to update the workspace
+                {
+                    name: config.name,
+                    root: config.root,
+                }, undefined, undefined, true);
+            }
+        }
+    }
+    return (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)(rootMap);
+}

package/src/project-graph/nx-deps-cache.d.ts

@@ -0,0 +1,48 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { FileData, FileMap, ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+export interface FileMapCache {
+    version: string;
+    nxVersion: string;
+    deps: Record<string, string>;
+    pathMappings: Record<string, any>;
+    nxJsonPlugins: PluginData[];
+    pluginsConfig?: any;
+    fileMap: FileMap;
+}
+export declare const nxProjectGraph: string;
+export declare const nxFileMap: string;
+export declare function ensureCacheDirectory(): void;
+export declare function readFileMapCache(): null | FileMapCache;
+export declare function readProjectGraphCache(): null | ProjectGraph;
+export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*' | string[]>, packageJsonDeps: Record<string, string>, fileMap: FileMap, tsConfig: {
+    compilerOptions?: {
+        paths?: {
+            [p: string]: any;
+        };
+    };
+}): FileMapCache;
+export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph): void;
+export declare function shouldRecomputeWholeGraph(cache: FileMapCache, packageJsonDeps: Record<string, string>, projects: Record<string, ProjectConfiguration>, nxJson: NxJsonConfiguration, tsConfig: {
+    compilerOptions: {
+        paths: {
+            [k: string]: any;
+        };
+    };
+}): boolean;
+export type CachedFileData = {
+    nonProjectFiles: Record<string, FileData>;
+    projectFileMap: {
+        [project: string]: Record<string, FileData>;
+    };
+};
+export declare function extractCachedFileData(fileMap: FileMap, c: FileMapCache): {
+    filesToProcess: FileMap;
+    cachedFileData: CachedFileData;
+};
+type PluginData = {
+    name: string;
+    version: string;
+    options?: unknown;
+};
+export {};