nx 17.0.2 → 17.0.4

package/src/project-graph/affected/locators/workspace-projects.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractGlobalFilesFromInputs = exports.getImplicitlyTouchedProjects = exports.getTouchedProjects = void 0;
-const minimatch = require("minimatch");
+exports.getImplicitlyTouchedProjects = exports.getTouchedProjects = void 0;
+const minimatch_1 = require("minimatch");
 const find_project_for_path_1 = require("../../utils/find-project-for-path");
 const getTouchedProjects = (touchedFiles, projectGraphNodes) => {
     const projectRootMap = (0, find_project_for_path_1.createProjectRootMappings)(projectGraphNodes);
@@ -16,15 +16,12 @@ const getTouchedProjects = (touchedFiles, projectGraphNodes) => {
 exports.getTouchedProjects = getTouchedProjects;
 const getImplicitlyTouchedProjects = (fileChanges, projectGraphNodes, nxJson) => {
     const implicits = {};
-    const globalFiles = [...extractGlobalFilesFromInputs(nxJson), 'nx.json'];
-    globalFiles.forEach((file) => {
-        implicits[file] = '*';
-    });
     Object.values(projectGraphNodes || {}).forEach((node) => {
-        [
-            ...extractFilesFromNamedInputs(node.data.namedInputs),
-            ...extractFilesFromTargetInputs(node.data.targets),
-        ].forEach((input) => {
+        const namedInputs = {
+            ...nxJson.namedInputs,
+            ...node.data.namedInputs,
+        };
+        extractFilesFromTargetInputs(node.data.targets, namedInputs).forEach((input) => {
             implicits[input] ??= [];
             if (Array.isArray(implicits[input])) {
                 implicits[input].push(node.name);
@@ -33,7 +30,7 @@ const getImplicitlyTouchedProjects = (fileChanges, projectGraphNodes, nxJson) =>
     });
     const touched = new Set();
     for (const [pattern, projects] of Object.entries(implicits)) {
-        const implicitDependencyWasChanged = fileChanges.some((f) => minimatch(f.file, pattern, { dot: true }));
+        const implicitDependencyWasChanged = fileChanges.some((f) => (0, minimatch_1.minimatch)(f.file, pattern, { dot: true }));
         if (!implicitDependencyWasChanged) {
             continue;
         }
@@ -48,33 +45,23 @@ const getImplicitlyTouchedProjects = (fileChanges, projectGraphNodes, nxJson) =>
     return Array.from(touched);
 };
 exports.getImplicitlyTouchedProjects = getImplicitlyTouchedProjects;
-function extractGlobalFilesFromInputs(nxJson) {
-    const globalFiles = [];
-    globalFiles.push(...extractFilesFromNamedInputs(nxJson.namedInputs));
-    globalFiles.push(...extractFilesFromTargetInputs(nxJson.targetDefaults));
-    return globalFiles;
-}
-exports.extractGlobalFilesFromInputs = extractGlobalFilesFromInputs;
-function extractFilesFromNamedInputs(namedInputs) {
-    const files = [];
-    for (const inputs of Object.values(namedInputs || {})) {
-        files.push(...extractFilesFromInputs(inputs));
-    }
-    return files;
-}
-function extractFilesFromTargetInputs(targets) {
+function extractFilesFromTargetInputs(targets, namedInputs) {
     const globalFiles = [];
     for (const target of Object.values(targets || {})) {
         if (target.inputs) {
-            globalFiles.push(...extractFilesFromInputs(target.inputs));
+            globalFiles.push(...extractFilesFromInputs(target.inputs, namedInputs));
         }
     }
     return globalFiles;
 }
-function extractFilesFromInputs(inputs) {
+function extractFilesFromInputs(inputs, namedInputs) {
     const globalFiles = [];
     for (const input of inputs) {
-        if (typeof input === 'string' && input.startsWith('{workspaceRoot}/')) {
+        if (typeof input === 'string' && input in namedInputs) {
+            return extractFilesFromInputs(namedInputs[input], namedInputs);
+        }
+        else if (typeof input === 'string' &&
+            input.startsWith('{workspaceRoot}/')) {
             globalFiles.push(input.substring('{workspaceRoot}/'.length));
         }
         else if (input.fileset && input.fileset.startsWith('{workspaceRoot}/')) {

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

@@ -2,11 +2,30 @@ import { FileData } from './file-utils';
 import { FileMapCache } from './nx-deps-cache';
 import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { NxWorkspaceFilesExternals } from '../native';
 export declare function getFileMap(): {
     fileMap: FileMap;
     allWorkspaceFiles: FileData[];
+    rustReferences: NxWorkspaceFilesExternals | null;
 };
-export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], fileMapCache: FileMapCache | null, shouldWriteCache: boolean): Promise<{
+export declare function buildProjectGraphUsingProjectFileMap(projects: Record<string, ProjectConfiguration>, externalNodes: Record<string, ProjectGraphExternalNode>, fileMap: FileMap, allWorkspaceFiles: FileData[], rustReferences: NxWorkspaceFilesExternals, fileMapCache: FileMapCache | null): Promise<{
     projectGraph: ProjectGraph;
     projectFileMapCache: FileMapCache;
 }>;
+export declare class ProcessDependenciesError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class ProcessProjectGraphError extends Error {
+    readonly pluginName: string;
+    constructor(pluginName: string, { cause }: {
+        cause: any;
+    });
+}
+export declare class CreateDependenciesError extends Error {
+    readonly errors: Array<ProcessDependenciesError | ProcessProjectGraphError>;
+    readonly partialProjectGraph: ProjectGraph;
+    constructor(errors: Array<ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph);
+}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildProjectGraphUsingProjectFileMap = exports.getFileMap = void 0;
+exports.CreateDependenciesError = exports.ProcessProjectGraphError = exports.ProcessDependenciesError = exports.buildProjectGraphUsingProjectFileMap = exports.getFileMap = void 0;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -14,13 +14,17 @@ const fileutils_1 = require("../utils/fileutils");
 const project_graph_builder_1 = require("./project-graph-builder");
 const configuration_1 = require("../config/configuration");
 const fs_1 = require("fs");
+const installation_directory_1 = require("../utils/installation-directory");
+const output_1 = require("../utils/output");
 let storedFileMap = null;
 let storedAllWorkspaceFiles = null;
+let storedRustReferences = null;
 function getFileMap() {
     if (!!storedFileMap) {
         return {
             fileMap: storedFileMap,
             allWorkspaceFiles: storedAllWorkspaceFiles,
+            rustReferences: storedRustReferences,
         };
     }
     else {
@@ -30,13 +34,15 @@ function getFileMap() {
                 projectFileMap: {},
             },
             allWorkspaceFiles: [],
+            rustReferences: null,
         };
     }
 }
 exports.getFileMap = getFileMap;
-async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, fileMapCache, shouldWriteCache) {
+async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, fileMapCache) {
     storedFileMap = fileMap;
     storedAllWorkspaceFiles = allWorkspaceFiles;
+    storedRustReferences = rustReferences;
     const nxJson = (0, configuration_1.readNxJson)();
     const projectGraphVersion = '6.0';
     (0, assert_workspace_validity_1.assertWorkspaceValidity)(projects, nxJson);
@@ -59,11 +65,8 @@ async function buildProjectGraphUsingProjectFileMap(projects, externalNodes, fil
         };
     }
     const context = createContext(projects, nxJson, externalNodes, fileMap, filesToProcess);
-    let projectGraph = await buildProjectGraphUsingContext(nxJson, externalNodes, context, cachedFileData, projectGraphVersion);
+    let projectGraph = await buildProjectGraphUsingContext(externalNodes, context, cachedFileData, projectGraphVersion);
     const projectFileMapCache = (0, nx_deps_cache_1.createProjectFileMapCache)(nxJson, packageJsonDeps, fileMap, rootTsConfig);
-    if (shouldWriteCache) {
-        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
-    }
     return {
         projectGraph,
         projectFileMapCache,
@@ -86,17 +89,30 @@ function readCombinedDeps() {
         ...installationPackageJson.devDependencies,
     };
 }
-async function buildProjectGraphUsingContext(nxJson, knownExternalNodes, ctx, cachedFileData, projectGraphVersion) {
+async function buildProjectGraphUsingContext(knownExternalNodes, ctx, cachedFileData, projectGraphVersion) {
     perf_hooks_1.performance.mark('build project graph:start');
     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, nxJson);
+    await (0, normalize_project_nodes_1.normalizeProjectNodes)(ctx, builder);
     const initProjectGraph = builder.getUpdatedProjectGraph();
-    const r = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
-    const updatedBuilder = new project_graph_builder_1.ProjectGraphBuilder(r, ctx.fileMap.projectFileMap);
+    let updatedGraph;
+    let error;
+    try {
+        updatedGraph = await updateProjectGraphWithPlugins(ctx, initProjectGraph);
+    }
+    catch (e) {
+        if (e instanceof CreateDependenciesError) {
+            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];
@@ -115,7 +131,12 @@ async function buildProjectGraphUsingContext(nxJson, knownExternalNodes, ctx, ca
     const finalGraph = updatedBuilder.getUpdatedProjectGraph();
     perf_hooks_1.performance.mark('build project graph:end');
     perf_hooks_1.performance.measure('build project graph', 'build project graph:start', 'build project graph:end');
-    return finalGraph;
+    if (!error) {
+        return finalGraph;
+    }
+    else {
+        throw new CreateDependenciesError(error.errors, finalGraph);
+    }
 }
 function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess) {
     const clonedProjects = Object.keys(projects).reduce((map, projectName) => {
@@ -134,20 +155,21 @@ function createContext(projects, nxJson, externalNodes, fileMap, filesToProcess)
     };
 }
 async function updateProjectGraphWithPlugins(context, initProjectGraph) {
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(context.nxJsonConfiguration?.plugins);
+    const plugins = await (0, nx_plugin_1.loadNxPlugins)(context.nxJsonConfiguration?.plugins, (0, installation_directory_1.getNxRequirePaths)(), context.workspaceRoot, context.projects);
     let graph = initProjectGraph;
+    const errors = [];
     for (const { plugin } of plugins) {
         try {
             if ((0, nx_plugin_1.isNxPluginV1)(plugin) &&
                 plugin.processProjectGraph &&
                 !plugin.createDependencies) {
-                // TODO(@AgentEnder): Enable after rewriting nx-js-graph-plugin to v2
-                // output.warn({
-                //   title: `${plugin.name} is a v1 plugin.`,
-                //   bodyLines: [
-                //     'Nx has recently released a v2 model for project graph plugins. The `processProjectGraph` method is deprecated. Plugins should use some combination of `createNodes` and `createDependencies` instead.',
-                //   ],
-                // });
+                output_1.output.warn({
+                    title: `${plugin.name} is a v1 plugin.`,
+                    bodyLines: [
+                        'Nx has recently released a v2 model for project graph plugins. The `processProjectGraph` method is deprecated. Plugins should use some combination of `createNodes` and `createDependencies` instead.',
+                    ],
+                });
+                perf_hooks_1.performance.mark(`${plugin.name}:processProjectGraph - start`);
                 graph = await plugin.processProjectGraph(graph, {
                     ...context,
                     projectsConfigurations: {
@@ -162,20 +184,20 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph) {
                         ...context.nxJsonConfiguration,
                     },
                 });
+                perf_hooks_1.performance.mark(`${plugin.name}:processProjectGraph - end`);
+                perf_hooks_1.performance.measure(`${plugin.name}:processProjectGraph`, `${plugin.name}:processProjectGraph - start`, `${plugin.name}:processProjectGraph - end`);
             }
         }
         catch (e) {
-            let message = `Failed to process the project graph with "${plugin.name}".`;
-            if (e instanceof Error) {
-                e.message = message + '\n' + e.message;
-                throw e;
-            }
-            throw new Error(message);
+            errors.push(new ProcessProjectGraphError(plugin.name, {
+                cause: e,
+            }));
         }
     }
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
     const createDependencyPlugins = plugins.filter(({ plugin }) => (0, nx_plugin_1.isNxPluginV2)(plugin) && plugin.createDependencies);
     await Promise.all(createDependencyPlugins.map(async ({ plugin, options }) => {
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
         try {
             const dependencies = await plugin.createDependencies(options, {
                 ...context,
@@ -184,17 +206,53 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph) {
                 builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
             }
         }
-        catch (e) {
-            let message = `Failed to process project dependencies with "${plugin.name}".`;
-            if (e instanceof Error) {
-                e.message = message + '\n' + e.message;
-                throw e;
-            }
-            throw new Error(message);
+        catch (cause) {
+            errors.push(new ProcessDependenciesError(plugin.name, {
+                cause,
+            }));
         }
+        perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - end`);
+        perf_hooks_1.performance.measure(`${plugin.name}:createDependencies`, `${plugin.name}:createDependencies - start`, `${plugin.name}:createDependencies - end`);
     }));
-    return builder.getUpdatedProjectGraph();
+    const result = builder.getUpdatedProjectGraph();
+    if (errors.length === 0) {
+        return result;
+    }
+    else {
+        throw new CreateDependenciesError(errors, result);
+    }
+}
+class ProcessDependenciesError extends Error {
+    constructor(pluginName, { cause }) {
+        super(`The "${pluginName}" plugin threw an error while creating dependencies:`, {
+            cause,
+        });
+        this.pluginName = pluginName;
+        this.name = this.constructor.name;
+        this.stack = `${this.message}\n  ${cause.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.ProcessDependenciesError = ProcessDependenciesError;
+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  ${cause.stack.split('\n').join('\n  ')}`;
+    }
+}
+exports.ProcessProjectGraphError = ProcessProjectGraphError;
+class CreateDependenciesError extends Error {
+    constructor(errors, partialProjectGraph) {
+        super('Failed to create dependencies. See above for errors');
+        this.errors = errors;
+        this.partialProjectGraph = partialProjectGraph;
+        this.name = this.constructor.name;
+    }
 }
+exports.CreateDependenciesError = CreateDependenciesError;
 function readRootTsConfig() {
     try {
         const tsConfigPath = (0, typescript_1.getRootTsConfigPath)();

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

@@ -1,11 +1,15 @@
 import { FileData, FileMap, ProjectFileMap, ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
-export declare function createProjectFileMapUsingProjectGraph(graph: ProjectGraph): Promise<ProjectFileMap>;
-export declare function createFileMap(projectsConfigurations: ProjectsConfigurations, allWorkspaceFiles: FileData[]): {
+import { NxWorkspaceFilesExternals } from '../native';
+export interface WorkspaceFileMap {
     allWorkspaceFiles: FileData[];
     fileMap: FileMap;
-};
-export declare function updateFileMap(projectsConfigurations: Record<string, ProjectConfiguration>, { projectFileMap, nonProjectFiles }: FileMap, allWorkspaceFiles: FileData[], updatedFiles: Map<string, string>, deletedFiles: string[]): {
-    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

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.updateFileMap = exports.createFileMap = exports.createProjectFileMapUsingProjectGraph = void 0;
-const find_project_for_path_1 = require("./utils/find-project-for-path");
+exports.updateFileMap = exports.createFileMap = exports.createFileMapUsingProjectGraph = exports.createProjectFileMapUsingProjectGraph = void 0;
 const client_1 = require("../daemon/client/client");
-const project_graph_1 = require("./project-graph");
 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;
+}
+exports.createProjectFileMapUsingProjectGraph = createProjectFileMapUsingProjectGraph;
+// 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;
     if (client_1.daemonClient.enabled()) {
@@ -15,9 +21,9 @@ async function createProjectFileMapUsingProjectGraph(graph) {
     else {
         files = (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
     }
-    return createFileMap(configs, files).fileMap.projectFileMap;
+    return createFileMap(configs, files);
 }
-exports.createProjectFileMapUsingProjectGraph = createProjectFileMapUsingProjectGraph;
+exports.createFileMapUsingProjectGraph = createFileMapUsingProjectGraph;
 function createFileMap(projectsConfigurations, allWorkspaceFiles) {
     const projectFileMap = {};
     const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations.projects);
@@ -46,65 +52,12 @@ function createFileMap(projectsConfigurations, allWorkspaceFiles) {
     };
 }
 exports.createFileMap = createFileMap;
-function updateFileMap(projectsConfigurations, { projectFileMap, nonProjectFiles }, allWorkspaceFiles, updatedFiles, deletedFiles) {
-    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projectsConfigurations);
-    let nonProjectFilesMap = new Map(nonProjectFiles.map((f) => [f.file, f]));
-    for (const f of updatedFiles.keys()) {
-        const project = (0, find_project_for_path_1.findProjectForPath)(f, projectRootMappings);
-        if (project) {
-            const matchingProjectFiles = projectFileMap[project] ?? [];
-            if (matchingProjectFiles) {
-                const fileData = matchingProjectFiles.find((t) => t.file === f);
-                if (fileData) {
-                    fileData.hash = updatedFiles.get(f);
-                }
-                else {
-                    matchingProjectFiles.push({
-                        file: f,
-                        hash: updatedFiles.get(f),
-                    });
-                }
-            }
-        }
-        else {
-            const hash = updatedFiles.get(f);
-            const entry = nonProjectFilesMap.get(f) ?? { file: f, hash };
-            entry.hash = hash;
-            nonProjectFilesMap.set(f, entry);
-        }
-        const fileData = allWorkspaceFiles.find((t) => t.file === f);
-        if (fileData) {
-            fileData.hash = updatedFiles.get(f);
-        }
-        else {
-            allWorkspaceFiles.push({
-                file: f,
-                hash: updatedFiles.get(f),
-            });
-        }
-    }
-    for (const f of deletedFiles) {
-        const matchingProjectFiles = projectFileMap[(0, find_project_for_path_1.findProjectForPath)(f, projectRootMappings)] ?? [];
-        if (matchingProjectFiles) {
-            const index = matchingProjectFiles.findIndex((t) => t.file === f);
-            if (index > -1) {
-                matchingProjectFiles.splice(index, 1);
-            }
-        }
-        if (nonProjectFilesMap.has(f)) {
-            nonProjectFilesMap.delete(f);
-        }
-        const index = allWorkspaceFiles.findIndex((t) => t.file === f);
-        if (index > -1) {
-            allWorkspaceFiles.splice(index, 1);
-        }
-    }
+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: {
-            projectFileMap,
-            nonProjectFiles: Array.from(nonProjectFilesMap.values()),
-        },
-        allWorkspaceFiles,
+        fileMap: updates.fileMap,
+        allWorkspaceFiles: (0, build_all_workspace_files_1.buildAllWorkspaceFiles)(updates.fileMap.projectFileMap, updates.fileMap.nonProjectFiles),
+        rustReferences: updates.externalReferences,
     };
 }
 exports.updateFileMap = updateFileMap;

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

@@ -18,7 +18,7 @@ export declare function isDeletedFileChange(change: Change): change is DeletedFi
 export declare function calculateFileChanges(files: string[], allWorkspaceFiles: FileData[], nxArgs?: NxArgs, readFileAtRevision?: (f: string, r: void | string) => string, ignore?: any): FileChange[];
 export declare const TEN_MEGABYTES: number;
 /**
- * TODO(v18): Remove this function
+ * TODO(v19): Remove this function
  * @deprecated To get projects use {@link retrieveProjectConfigurations} instead
  */
 export declare function readWorkspaceConfig(opts: {

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

@@ -12,6 +12,10 @@ const project_graph_1 = require("./project-graph");
 const angular_json_1 = require("../adapter/angular-json");
 const ignore_1 = require("../utils/ignore");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
+const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const nx_plugin_deprecated_1 = require("../utils/nx-plugin.deprecated");
+const minimatch_1 = require("minimatch");
+const package_json_next_to_project_json_1 = require("../plugins/project-json/build-nodes/package-json-next-to-project-json");
 class WholeFileChange {
     constructor() {
         this.type = 'WholeFileChange';
@@ -94,7 +98,7 @@ function defaultReadFileAtRevision(file, revision) {
     }
 }
 /**
- * TODO(v18): Remove this function
+ * TODO(v19): Remove this function
  * @deprecated To get projects use {@link retrieveProjectConfigurations} instead
  */
 function readWorkspaceConfig(opts) {
@@ -111,7 +115,7 @@ function readWorkspaceConfig(opts) {
     catch {
         configuration = {
             version: 2,
-            projects: (0, retrieve_workspace_files_1.retrieveProjectConfigurationsSync)(root, nxJson).projectNodes,
+            projects: getProjectsSyncNoInference(root, nxJson).projects,
         };
     }
     if (opts.format === 'angularCli') {
@@ -139,3 +143,41 @@ exports.readPackageJson = readPackageJson;
 var configuration_2 = require("../config/configuration");
 Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return configuration_2.readNxJson; } });
 Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: function () { return configuration_2.workspaceLayout; } });
+/**
+ * TODO(v19): Remove this function.
+ */
+function getProjectsSyncNoInference(root, nxJson) {
+    const allConfigFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPaths)(root, (0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root));
+    const plugins = [
+        { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
+        ...(0, nx_plugin_deprecated_1.getDefaultPluginsSync)(root),
+    ];
+    const projectRootMap = new Map();
+    // We iterate over plugins first - this ensures that plugins specified first take precedence.
+    for (const { plugin, options } of plugins) {
+        const [pattern, createNodes] = plugin.createNodes ?? [];
+        if (!pattern) {
+            continue;
+        }
+        const matchingConfigFiles = allConfigFiles.filter((file) => (0, minimatch_1.minimatch)(file, pattern, { dot: true }));
+        for (const file of matchingConfigFiles) {
+            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
+                let r = createNodes(file, options, {
+                    nxJsonConfiguration: nxJson,
+                    workspaceRoot: root,
+                    configFiles: matchingConfigFiles,
+                });
+                for (const node in r.projects) {
+                    const project = {
+                        root: node,
+                        ...r.projects[node],
+                    };
+                    (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(projectRootMap, project);
+                }
+            }
+        }
+    }
+    return {
+        projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)(projectRootMap),
+    };
+}

package/src/project-graph/nx-deps-cache.js

@@ -74,7 +74,7 @@ function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig) {
     const newValue = {
         version: '6.0',
         nxVersion: versions_1.nxVersion,
-        deps: packageJsonDeps,
+        deps: packageJsonDeps, // TODO(v19): We can remove this in favor of nxVersion
         // compilerOptions may not exist, especially for package-based repos
         pathMappings: tsConfig?.compilerOptions?.paths || {},
         nxJsonPlugins,

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

@@ -5,7 +5,7 @@ import { DependencyType, FileMap, ProjectFileMap, ProjectGraph, ProjectGraphExte
 import { CreateDependenciesContext } from '../utils/nx-plugin';
 /**
  * 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 18.
+ * @deprecated The {@link ProjectGraphProcessor} has been deprecated. Use a {@link CreateNodes} and/or a {@link CreateDependencies} instead. This will be removed in Nx 19.
  */
 export declare class ProjectGraphBuilder {
     readonly graph: ProjectGraph;

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

@@ -8,7 +8,7 @@ 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 18.
+ * @deprecated The {@link ProjectGraphProcessor} has been deprecated. Use a {@link CreateNodes} and/or a {@link CreateDependencies} instead. This will be removed in Nx 19.
  */
 class ProjectGraphBuilder {
     constructor(graph, projectFileMap, nonProjectFiles) {

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

@@ -1,5 +1,8 @@
+import { ProcessDependenciesError, ProcessProjectGraphError } from './build-project-graph';
 import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { ConfigurationSourceMaps, CreateNodesError, MergeNodesError } from './utils/project-configuration-utils';
+import { DaemonProjectGraphError } from '../daemon/daemon-project-graph-error';
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -10,7 +13,28 @@ export declare function readCachedProjectConfiguration(projectName: string): Pro
  * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}
  */
 export declare function readProjectsConfigurationFromProjectGraph(projectGraph: ProjectGraph): ProjectsConfigurations;
-export declare function buildProjectGraphWithoutDaemon(): Promise<ProjectGraph>;
+export declare function buildProjectGraphAndSourceMapsWithoutDaemon(): Promise<{
+    projectGraph: ProjectGraph;
+    sourceMaps: ConfigurationSourceMaps;
+}>;
+export declare class ProjectGraphError extends Error {
+    #private;
+    constructor(errors: Array<CreateNodesError | MergeNodesError | ProcessDependenciesError | ProcessProjectGraphError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
+    /**
+     * 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(): (ProcessDependenciesError | ProcessProjectGraphError | CreateNodesError)[];
+}
 /**
  * Computes and returns a ProjectGraph.
  *
@@ -36,3 +60,10 @@ export declare function createProjectGraphAsync(opts?: {
     exitOnError: boolean;
     resetDaemonClient?: boolean;
 }): Promise<ProjectGraph>;
+export declare function createProjectGraphAndSourceMapsAsync(opts?: {
+    exitOnError: boolean;
+    resetDaemonClient?: boolean;
+}): Promise<{
+    projectGraph: ProjectGraph;
+    sourceMaps: ConfigurationSourceMaps;
+}>;