nx 16.7.1 → 16.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "16.7.1",
+  "version": "16.7.2",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -32,7 +32,7 @@
   },
   "homepage": "https://nx.dev",
   "dependencies": {
-    "@nrwl/tao": "16.7.1",
+    "@nrwl/tao": "16.7.2",
     "@parcel/watcher": "2.0.4",
     "@yarnpkg/lockfile": "^1.1.0",
     "@yarnpkg/parsers": "3.0.0-rc.46",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "16.7.1",
-    "@nx/nx-darwin-x64": "16.7.1",
-    "@nx/nx-freebsd-x64": "16.7.1",
-    "@nx/nx-linux-arm-gnueabihf": "16.7.1",
-    "@nx/nx-linux-arm64-gnu": "16.7.1",
-    "@nx/nx-linux-arm64-musl": "16.7.1",
-    "@nx/nx-linux-x64-gnu": "16.7.1",
-    "@nx/nx-linux-x64-musl": "16.7.1",
-    "@nx/nx-win32-arm64-msvc": "16.7.1",
-    "@nx/nx-win32-x64-msvc": "16.7.1"
+    "@nx/nx-darwin-arm64": "16.7.2",
+    "@nx/nx-darwin-x64": "16.7.2",
+    "@nx/nx-freebsd-x64": "16.7.2",
+    "@nx/nx-linux-arm-gnueabihf": "16.7.2",
+    "@nx/nx-linux-arm64-gnu": "16.7.2",
+    "@nx/nx-linux-arm64-musl": "16.7.2",
+    "@nx/nx-linux-x64-gnu": "16.7.2",
+    "@nx/nx-linux-x64-musl": "16.7.2",
+    "@nx/nx-win32-arm64-msvc": "16.7.2",
+    "@nx/nx-win32-x64-msvc": "16.7.2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -177,5 +177,5 @@
   },
   "main": "./bin/nx.js",
   "type": "commonjs",
-  "gitHead": "8b38708d6c18496711695499d07c95f3ecc31cc9"
+  "gitHead": "b024f44a1ad4e1773e80f6dc72f9d22766b950f9"
 }

package/plugins/package-json-workspaces.d.ts

@@ -1,10 +1,16 @@
 import { NxJsonConfiguration } from '../src/config/nx-json';
 import { ProjectConfiguration } from '../src/config/workspace-json-project-json';
 import { NxPluginV2 } from '../src/utils/nx-plugin';
+import { PackageJson } from '../src/utils/package-json';
 export declare function getNxPackageJsonWorkspacesPlugin(root: string): NxPluginV2;
-export declare function buildProjectConfigurationFromPackageJson(packageJson: {
-    name: string;
-}, path: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {
+export declare function createNodeFromPackageJson(pkgJsonPath: string, root: string): {
+    projects: {
+        [x: string]: ProjectConfiguration & {
+            name: string;
+        };
+    };
+};
+export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, path: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {
     name: string;
 };
 /**

package/plugins/package-json-workspaces.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.getNxPackageJsonWorkspacesPlugin = void 0;
+exports.getGlobPatternsFromPackageManagerWorkspaces = exports.buildProjectConfigurationFromPackageJson = exports.createNodeFromPackageJson = exports.getNxPackageJsonWorkspacesPlugin = void 0;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const nx_json_1 = require("../src/config/nx-json");
@@ -9,6 +9,7 @@ const fileutils_1 = require("../src/utils/fileutils");
 const globs_1 = require("../src/utils/globs");
 const logger_1 = require("../src/utils/logger");
 const output_1 = require("../src/utils/output");
+const package_json_1 = require("../src/utils/package-json");
 const path_1 = require("../src/utils/path");
 function getNxPackageJsonWorkspacesPlugin(root) {
     const readJson = (f) => (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, f));
@@ -16,18 +17,20 @@ function getNxPackageJsonWorkspacesPlugin(root) {
         name: 'nx-core-build-package-json-nodes',
         createNodes: [
             (0, globs_1.combineGlobPatterns)(getGlobPatternsFromPackageManagerWorkspaces(root, readJson)),
-            (pkgJsonPath) => {
-                const json = readJson(pkgJsonPath);
-                return {
-                    projects: {
-                        [json.name]: buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root)),
-                    },
-                };
-            },
+            (p) => createNodeFromPackageJson(p, root),
         ],
     };
 }
 exports.getNxPackageJsonWorkspacesPlugin = getNxPackageJsonWorkspacesPlugin;
+function createNodeFromPackageJson(pkgJsonPath, root) {
+    const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, pkgJsonPath));
+    return {
+        projects: {
+            [json.name]: buildProjectConfigurationFromPackageJson(json, pkgJsonPath, (0, nx_json_1.readNxJson)(root)),
+        },
+    };
+}
+exports.createNodeFromPackageJson = createNodeFromPackageJson;
 function buildProjectConfigurationFromPackageJson(packageJson, path, nxJson) {
     var _a, _b, _c, _d;
     const normalizedPath = path.split('\\').join('/');
@@ -47,12 +50,8 @@ function buildProjectConfigurationFromPackageJson(packageJson, path, nxJson) {
         directory.startsWith(nxJson.workspaceLayout.appsDir)
         ? 'application'
         : 'library';
-    return {
-        root: directory,
-        sourceRoot: directory,
-        name,
-        projectType,
-    };
+    return Object.assign(Object.assign({ root: directory, sourceRoot: directory, name,
+        projectType }, packageJson.nx), { targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson) });
 }
 exports.buildProjectConfigurationFromPackageJson = buildProjectConfigurationFromPackageJson;
 /**

package/plugins/package-json.d.ts

@@ -1 +1 @@
-export declare const projectFilePatterns: string[];
+export {};

package/plugins/package-json.js

@@ -1,4 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectFilePatterns = void 0;
-exports.projectFilePatterns = ['package.json'];
+const workspace_root_1 = require("../src/utils/workspace-root");
+const package_json_workspaces_1 = require("./package-json-workspaces");
+const plugin = {
+    name: 'nx-all-package-jsons-plugin',
+    createNodes: [
+        '*/**/package.json',
+        (f) => (0, package_json_workspaces_1.createNodeFromPackageJson)(f, workspace_root_1.workspaceRoot),
+    ],
+};
+module.exports = plugin;

package/plugins/project-json.d.ts

@@ -1,4 +1,7 @@
-import { ProjectConfiguration } from '../src/config/workspace-json-project-json';
+import { ProjectConfiguration, TargetConfiguration } from '../src/config/workspace-json-project-json';
 import { NxPluginV2 } from '../src/utils/nx-plugin';
+import { PackageJson } from '../src/utils/package-json';
 export declare function getNxProjectJsonPlugin(root: string): NxPluginV2;
 export declare function buildProjectFromProjectJson(json: Partial<ProjectConfiguration>, path: string): ProjectConfiguration;
+export declare function mergePackageJsonConfigurationWithProjectJson(p: ProjectConfiguration, root: string): void;
+export declare function mergeNpmScriptsWithTargets(packageJson: PackageJson, targets: Record<string, TargetConfiguration>): Record<string, TargetConfiguration>;

package/plugins/project-json.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildProjectFromProjectJson = exports.getNxProjectJsonPlugin = void 0;
+exports.mergeNpmScriptsWithTargets = exports.mergePackageJsonConfigurationWithProjectJson = exports.buildProjectFromProjectJson = exports.getNxProjectJsonPlugin = void 0;
 const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 const workspaces_1 = require("../src/config/workspaces");
 const fileutils_1 = require("../src/utils/fileutils");
+const package_json_1 = require("../src/utils/package-json");
 function getNxProjectJsonPlugin(root) {
     return {
         name: 'nx-core-build-project-json-nodes',
@@ -12,6 +14,7 @@ function getNxProjectJsonPlugin(root) {
             (file) => {
                 const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, file));
                 const project = buildProjectFromProjectJson(json, file);
+                mergePackageJsonConfigurationWithProjectJson(project, root);
                 return {
                     projects: {
                         [project.name]: project,
@@ -26,3 +29,37 @@ function buildProjectFromProjectJson(json, path) {
     return Object.assign({ name: (0, workspaces_1.toProjectName)(path), root: (0, node_path_1.dirname)(path) }, json);
 }
 exports.buildProjectFromProjectJson = buildProjectFromProjectJson;
+function mergePackageJsonConfigurationWithProjectJson(p, root) {
+    if ((0, node_fs_1.existsSync)((0, node_path_1.join)(root, p.root, 'package.json'))) {
+        try {
+            const packageJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(root, p.root, 'package.json'));
+            p.targets = mergeNpmScriptsWithTargets(packageJson, p.targets);
+            const { nx } = packageJson;
+            if (nx === null || nx === void 0 ? void 0 : nx.tags) {
+                p.tags = [...(p.tags || []), ...nx.tags];
+            }
+            if (nx === null || nx === void 0 ? void 0 : nx.implicitDependencies) {
+                p.implicitDependencies = [
+                    ...(p.implicitDependencies || []),
+                    ...nx.implicitDependencies,
+                ];
+            }
+            if (nx === null || nx === void 0 ? void 0 : nx.namedInputs) {
+                p.namedInputs = Object.assign(Object.assign({}, (p.namedInputs || {})), nx.namedInputs);
+            }
+        }
+        catch (e) {
+            // ignore json parser errors
+        }
+    }
+}
+exports.mergePackageJsonConfigurationWithProjectJson = mergePackageJsonConfigurationWithProjectJson;
+function mergeNpmScriptsWithTargets(packageJson, targets) {
+    try {
+        return Object.assign(Object.assign({}, (0, package_json_1.readTargetsFromPackageJson)(packageJson)), (targets || {}));
+    }
+    catch (e) {
+        return targets;
+    }
+}
+exports.mergeNpmScriptsWithTargets = mergeNpmScriptsWithTargets;

package/schemas/nx-schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema",
-  "$id": "https://nx.dev/core-concepts/configuration#nxjson",
+  "$id": "https://nx.dev/reference/nx-json",
   "title": "JSON schema for Nx configuration",
   "type": "object",
   "properties": {

package/schemas/project-schema.json

@@ -1,6 +1,6 @@
 {
   "$schema": "http://json-schema.org/draft-07/schema",
-  "$id": "https://nx.dev/project-schema",
+  "$id": "https://nx.dev/reference/project-configuration",
   "title": "JSON schema for Nx projects",
   "type": "object",
   "properties": {

package/src/adapter/angular-json.d.ts

@@ -1,11 +1,9 @@
-import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { ProjectsConfigurations } from '../config/workspace-json-project-json';
+import { NxPluginV2 } from '../devkit-exports';
+export declare const NX_ANGULAR_JSON_PLUGIN_NAME = "nx-angular-json-plugin";
+export declare const NxAngularJsonPlugin: NxPluginV2;
 export declare function shouldMergeAngularProjects(root: string, includeProjectsFromAngularJson: boolean): boolean;
 export declare function isAngularPluginInstalled(): boolean;
-export declare function mergeAngularJsonAndProjects(projects: {
-    [name: string]: ProjectConfiguration;
-}, angularCliWorkspaceRoot: string): {
-    [name: string]: ProjectConfiguration;
-};
 export declare function toNewFormat(w: any): ProjectsConfigurations;
 export declare function toOldFormat(w: any): any;
 export declare function renamePropertyWithStableKeys(obj: any, from: string, to: string): void;

package/src/adapter/angular-json.js

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.renamePropertyWithStableKeys = exports.toOldFormat = exports.toNewFormat = exports.mergeAngularJsonAndProjects = exports.isAngularPluginInstalled = exports.shouldMergeAngularProjects = void 0;
+exports.renamePropertyWithStableKeys = exports.toOldFormat = exports.toNewFormat = exports.isAngularPluginInstalled = exports.shouldMergeAngularProjects = exports.NxAngularJsonPlugin = exports.NX_ANGULAR_JSON_PLUGIN_NAME = void 0;
 const fs_1 = require("fs");
 const path = require("path");
 const fileutils_1 = require("../utils/fileutils");
+exports.NX_ANGULAR_JSON_PLUGIN_NAME = 'nx-angular-json-plugin';
+exports.NxAngularJsonPlugin = {
+    name: exports.NX_ANGULAR_JSON_PLUGIN_NAME,
+    createNodes: [
+        'angular.json',
+        (f, ctx) => ({
+            projects: readAngularJson(ctx.workspaceRoot),
+        }),
+    ],
+};
 function shouldMergeAngularProjects(root, includeProjectsFromAngularJson) {
     if ((0, fs_1.existsSync)(path.join(root, 'angular.json')) &&
         // Include projects from angular.json if explicitly required.
@@ -38,20 +48,6 @@ exports.isAngularPluginInstalled = isAngularPluginInstalled;
 function readAngularJson(angularCliWorkspaceRoot) {
     return toNewFormat((0, fileutils_1.readJsonFile)(path.join(angularCliWorkspaceRoot, 'angular.json'))).projects;
 }
-function mergeAngularJsonAndProjects(projects, angularCliWorkspaceRoot) {
-    const res = readAngularJson(angularCliWorkspaceRoot);
-    const folders = new Set();
-    for (let k of Object.keys(res)) {
-        folders.add(res[k].root);
-    }
-    for (let k of Object.keys(projects)) {
-        if (!folders.has(projects[k].root)) {
-            res[k] = projects[k];
-        }
-    }
-    return res;
-}
-exports.mergeAngularJsonAndProjects = mergeAngularJsonAndProjects;
 function toNewFormat(w) {
     Object.values(w.projects || {}).forEach((projectConfig) => {
         if (projectConfig.architect) {

package/src/devkit-internals.d.ts

@@ -8,3 +8,8 @@ export { getExecutorInformation } from './command-line/run/executor-utils';
 export { readNxJson as readNxJsonFromDisk } from './config/nx-json';
 export { calculateDefaultProjectName } from './config/calculate-default-project-name';
 export { retrieveProjectConfigurationsWithAngularProjects } from './project-graph/utils/retrieve-workspace-files';
+export { splitTarget } from './utils/split-target';
+export { combineOptionsForExecutor } from './utils/params';
+export { sortObjectByKeys } from './utils/object-sort';
+export { stripIndent } from './utils/logger';
+export { readModulePackageJson } from './utils/package-json';

package/src/devkit-internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
+exports.readModulePackageJson = exports.stripIndent = exports.sortObjectByKeys = exports.combineOptionsForExecutor = exports.splitTarget = exports.retrieveProjectConfigurationsWithAngularProjects = exports.calculateDefaultProjectName = exports.readNxJsonFromDisk = exports.getExecutorInformation = exports.createTempNpmDirectory = void 0;
 /**
  * Note to developers: STOP! These exports are available via requireNx in @nx/devkit.
  *
@@ -16,3 +16,13 @@ var calculate_default_project_name_1 = require("./config/calculate-default-proje
 Object.defineProperty(exports, "calculateDefaultProjectName", { enumerable: true, get: function () { return calculate_default_project_name_1.calculateDefaultProjectName; } });
 var retrieve_workspace_files_1 = require("./project-graph/utils/retrieve-workspace-files");
 Object.defineProperty(exports, "retrieveProjectConfigurationsWithAngularProjects", { enumerable: true, get: function () { return retrieve_workspace_files_1.retrieveProjectConfigurationsWithAngularProjects; } });
+var split_target_1 = require("./utils/split-target");
+Object.defineProperty(exports, "splitTarget", { enumerable: true, get: function () { return split_target_1.splitTarget; } });
+var params_1 = require("./utils/params");
+Object.defineProperty(exports, "combineOptionsForExecutor", { enumerable: true, get: function () { return params_1.combineOptionsForExecutor; } });
+var object_sort_1 = require("./utils/object-sort");
+Object.defineProperty(exports, "sortObjectByKeys", { enumerable: true, get: function () { return object_sort_1.sortObjectByKeys; } });
+var logger_1 = require("./utils/logger");
+Object.defineProperty(exports, "stripIndent", { enumerable: true, get: function () { return logger_1.stripIndent; } });
+var package_json_1 = require("./utils/package-json");
+Object.defineProperty(exports, "readModulePackageJson", { enumerable: true, get: function () { return package_json_1.readModulePackageJson; } });

package/src/generators/utils/project-configuration.js

@@ -118,7 +118,6 @@ function getRelativeProjectJsonSchemaPath(tree, project) {
 }
 exports.getRelativeProjectJsonSchemaPath = getRelativeProjectJsonSchemaPath;
 function readAndCombineAllProjectConfigurations(tree) {
-    const nxJson = (0, nx_json_1.readNxJson)(tree);
     /**
      * 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
@@ -134,16 +133,16 @@ function readAndCombineAllProjectConfigurations(tree) {
     const deletedFiles = findDeletedProjectFiles(tree, patterns);
     const projectFiles = [...globbedFiles, ...createdFiles].filter((r) => deletedFiles.indexOf(r) === -1);
     const rootMap = new Map();
-    return projectFiles.reduce((projects, projectFile) => {
+    for (const projectFile of projectFiles) {
         if ((0, path_1.basename)(projectFile) === 'project.json') {
             const json = (0, json_1.readJson)(tree, projectFile);
             const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
-            (0, project_configuration_utils_1.mergeProjectConfigurationIntoProjectsConfigurations)(projects, rootMap, config, projectFile);
+            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, projectFile);
         }
         else {
             const packageJson = (0, json_1.readJson)(tree, projectFile);
             const config = (0, package_json_workspaces_1.buildProjectConfigurationFromPackageJson)(packageJson, projectFile, (0, nx_json_1.readNxJson)(tree));
-            (0, project_configuration_utils_1.mergeProjectConfigurationIntoProjectsConfigurations)(projects, rootMap, 
+            (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
             {
@@ -151,8 +150,8 @@ function readAndCombineAllProjectConfigurations(tree) {
                 root: config.root,
             }, projectFile);
         }
-        return projects;
-    }, {});
+    }
+    return (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)(rootMap);
 }
 /**
  * Used to ensure that projects created during

package/src/plugins/js/index.js

@@ -23,12 +23,16 @@ const processProjectGraph = (graph, context) => tslib_1.__awaiter(void 0, void 0
             let parsedLockFile;
             if (lockFileNeedsReprocessing(lockHash)) {
                 parsedLockFile = (0, lock_file_1.parseLockFile)();
-                writeLastProcessedLockfileHash(lockHash, parsedLockFile);
+                if (parsedLockFile) {
+                    writeLastProcessedLockfileHash(lockHash, parsedLockFile);
+                }
             }
             else {
                 parsedLockFile = readParsedLockFile();
             }
-            builder.mergeProjectGraph(parsedLockFile);
+            if (parsedLockFile) {
+                builder.mergeProjectGraph(parsedLockFile);
+            }
         }
     }
     perf_hooks_1.performance.mark('build typescript dependencies - start');

package/src/plugins/js/lock-file/yarn-parser.js

@@ -18,13 +18,18 @@ function parseYarnLockfile(lockFileContent, packageJson, builder) {
     addDependencies(groupedDependencies, builder, keyMap);
 }
 exports.parseYarnLockfile = parseYarnLockfile;
-function getPackageNames(keys) {
-    const packageNames = new Set();
+function getPackageNameKeyPairs(keys) {
+    const result = new Map();
     keys.split(', ').forEach((key) => {
         const packageName = key.slice(0, key.indexOf('@', 1));
-        packageNames.add(packageName);
+        if (result.has(packageName)) {
+            result.get(packageName).add(key);
+        }
+        else {
+            result.set(packageName, new Set([key]));
+        }
     });
-    return Array.from(packageNames);
+    return result;
 }
 function addNodes(dependencies, packageJson, builder, keyMap, isBerry) {
     const nodes = new Map();
@@ -34,10 +39,13 @@ function addNodes(dependencies, packageJson, builder, keyMap, isBerry) {
         if (snapshot.linkType === 'soft' || keys.includes('@patch:')) {
             return;
         }
-        const packageNames = getPackageNames(keys);
-        packageNames.forEach((packageName) => {
-            const version = findVersion(packageName, keys.split(', ')[0], snapshot, isBerry);
-            keys.split(', ').forEach((key) => {
+        const nameKeyPairs = getPackageNameKeyPairs(keys);
+        nameKeyPairs.forEach((keySet, packageName) => {
+            const keysArray = Array.from(keySet);
+            // use key relevant to the package name
+            const version = findVersion(packageName, keysArray[0], snapshot, isBerry);
+            // use keys linked to the extracted package name
+            keysArray.forEach((key) => {
                 var _a;
                 // we don't need to keep duplicates, we can just track the keys
                 const existingNode = (_a = nodes.get(packageName)) === null || _a === void 0 ? void 0 : _a.get(version);
@@ -111,7 +119,7 @@ function findHoistedNode(packageName, versionMap, combinedDeps) {
     }
 }
 function findVersion(packageName, key, snapshot, isBerry) {
-    const versionRange = key.slice(packageName.length + 1);
+    const versionRange = key.slice(key.indexOf('@', 1) + 1);
     // check for alias packages
     const isAlias = isBerry
         ? snapshot.resolution && !snapshot.resolution.startsWith(`${packageName}@`)

package/src/project-graph/build-nodes/workspace-projects.js

@@ -2,11 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
 const tslib_1 = require("tslib");
-const path_1 = require("path");
-const fs_1 = require("fs");
-const workspace_root_1 = require("../../utils/workspace-root");
-const project_graph_utils_1 = require("../../utils/project-graph-utils");
-const fileutils_1 = require("../../utils/fileutils");
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 const logger_1 = require("../../utils/logger");
 const project_configuration_utils_1 = require("../utils/project-configuration-utils");
@@ -27,33 +22,6 @@ function normalizeProjectNodes(ctx, builder, nxJson) {
         }, {});
         for (const key of projects) {
             const p = ctx.projectsConfigurations.projects[key];
-            const projectRoot = (0, path_1.join)(workspace_root_1.workspaceRoot, p.root);
-            // Todo(@AgentEnder) we can move a lot of this to
-            // builtin plugin inside workspaces.ts, but there would be some functional differences
-            // - The plugin would only apply to package.json files found via the workspaces globs
-            //   - This means that scripts / tags / etc from the `nx` property wouldn't be read if a project
-            //     is being found by project.json and not included in the workspaces configuration. Maybe this is fine?
-            if ((0, fs_1.existsSync)((0, path_1.join)(projectRoot, 'package.json'))) {
-                p.targets = (0, project_graph_utils_1.mergeNpmScriptsWithTargets)(projectRoot, p.targets);
-                try {
-                    const { nx } = (0, fileutils_1.readJsonFile)((0, path_1.join)(projectRoot, 'package.json'));
-                    if (nx === null || nx === void 0 ? void 0 : nx.tags) {
-                        p.tags = [...(p.tags || []), ...nx.tags];
-                    }
-                    if (nx === null || nx === void 0 ? void 0 : nx.implicitDependencies) {
-                        p.implicitDependencies = [
-                            ...(p.implicitDependencies || []),
-                            ...nx.implicitDependencies,
-                        ];
-                    }
-                    if (nx === null || nx === void 0 ? void 0 : nx.namedInputs) {
-                        p.namedInputs = Object.assign(Object.assign({}, (p.namedInputs || {})), nx.namedInputs);
-                    }
-                }
-                catch (_c) {
-                    // ignore json parser errors
-                }
-            }
             p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
             p.targets = normalizeProjectTargets(p, nxJson.targetDefaults, key);
             // TODO: remove in v16

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

@@ -21,7 +21,7 @@ export declare function buildProjectGraphWithoutDaemon(): Promise<ProjectGraph>;
  * * 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`.
- * * `useDaemon` is set to false in `nx.json`
+ * * `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.

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

@@ -95,7 +95,7 @@ function handleProjectGraphError(opts, e) {
  * * 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`.
- * * `useDaemon` is set to false in `nx.json`
+ * * `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.

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

@@ -2,12 +2,13 @@ import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
 import { NxPluginV2 } from '../../utils/nx-plugin';
-export declare function mergeProjectConfigurationIntoProjectsConfigurations(existingProjects: Record<string, ProjectConfiguration>, existingProjectRootMap: Map<string, string>, project: ProjectConfiguration, file: string): void;
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration, file: string): void;
 export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
 plugins: NxPluginV2[], root?: string): {
     projects: Record<string, ProjectConfiguration>;
     externalNodes: Record<string, ProjectGraphExternalNode>;
 };
+export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 export declare function mergeTargetConfigurations(projectConfiguration: ProjectConfiguration, target: string, targetDefaults: TargetDefaults[string]): TargetConfiguration;
 export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
 export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.mergeTargetConfigurations = exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = exports.mergeProjectConfigurationIntoProjectsConfigurations = void 0;
+exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const tslib_1 = require("tslib");
 const node_path_1 = require("node:path");
 const package_json_workspaces_1 = require("../../../plugins/package-json-workspaces");
@@ -8,38 +8,27 @@ const project_json_1 = require("../../../plugins/project-json");
 const logger_1 = require("../../utils/logger");
 const workspace_root_1 = require("../../utils/workspace-root");
 const minimatch = require("minimatch");
-function mergeProjectConfigurationIntoProjectsConfigurations(
-// projectName -> ProjectConfiguration
-existingProjects, 
-// projectRoot -> projectName
-existingProjectRootMap, project, 
+function mergeProjectConfigurationIntoRootMap(projectRootMap, project, 
 // project.json is a special case, so we need to detect it.
 file) {
-    let matchingProjectName = existingProjectRootMap.get(project.root);
-    if (!matchingProjectName) {
-        existingProjects[project.name] = project;
-        existingProjectRootMap.set(project.root, project.name);
+    const matchingProject = projectRootMap.get(project.root);
+    if (!matchingProject) {
+        projectRootMap.set(project.root, project);
         return;
-        // There are some special cases for handling project.json - mainly
-        // that it should override any name the project already has.
     }
     else if (project.name &&
-        project.name !== matchingProjectName &&
+        project.name !== matchingProject.name &&
         (0, node_path_1.basename)(file) === 'project.json') {
-        // Copy config to new name
-        existingProjects[project.name] = existingProjects[matchingProjectName];
-        // Update name in project config
-        existingProjects[project.name].name = project.name;
-        // Update root map to point to new name
-        existingProjectRootMap[project.root] = project.name;
-        // Remove entry for old name
-        delete existingProjects[matchingProjectName];
-        // Update name that config should be merged to
-        matchingProjectName = project.name;
+        // `name` inside project.json overrides any names from
+        // inference plugins
+        matchingProject.name = project.name;
     }
-    const matchingProject = existingProjects[matchingProjectName];
-    // This handles top level properties that are overwritten. `srcRoot`, `projectType`, or fields that Nx doesn't know about.
-    const updatedProjectConfiguration = Object.assign(Object.assign(Object.assign({}, matchingProject), project), { name: matchingProjectName });
+    // This handles top level properties that are overwritten.
+    // e.g. `srcRoot`, `projectType`, or other fields that shouldn't be extended
+    // Note: `name` is set specifically here to keep it from changing. The name is
+    // always determined by the first inference plugin to ID a project, unless it has
+    // a project.json in which case it was already updated above.
+    const updatedProjectConfiguration = Object.assign(Object.assign(Object.assign({}, matchingProject), project), { name: matchingProject.name });
     // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
     if (project.tags && matchingProject.tags) {
         updatedProjectConfiguration.tags = matchingProject.tags.concat(project.tags);
@@ -54,18 +43,14 @@ file) {
     if (project.targets && matchingProject.targets) {
         updatedProjectConfiguration.targets = Object.assign(Object.assign({}, matchingProject.targets), project.targets);
     }
-    if (updatedProjectConfiguration.name !== matchingProject.name) {
-        delete existingProjects[matchingProject.name];
-    }
-    existingProjects[updatedProjectConfiguration.name] =
-        updatedProjectConfiguration;
+    projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
 }
-exports.mergeProjectConfigurationIntoProjectsConfigurations = mergeProjectConfigurationIntoProjectsConfigurations;
+exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
 plugins, root = workspace_root_1.workspaceRoot) {
-    var _a;
+    var _a, _b;
+    var _c;
     const projectRootMap = new Map();
-    const projects = {};
     const externalNodes = {};
     // We push the nx core node builder onto the end, s.t. it overwrites any user specified behavior
     plugins.push((0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root), (0, project_json_1.getNxProjectJsonPlugin)(root));
@@ -78,20 +63,56 @@ plugins, root = workspace_root_1.workspaceRoot) {
         for (const file of projectFiles) {
             if (minimatch(file, pattern)) {
                 const { projects: projectNodes, externalNodes: pluginExternalNodes } = configurationConstructor(file, {
-                    projectsConfigurations: projects,
                     nxJsonConfiguration: nxJson,
                     workspaceRoot: root,
                 });
                 for (const node in projectNodes) {
-                    mergeProjectConfigurationIntoProjectsConfigurations(projects, projectRootMap, projectNodes[node], file);
+                    (_b = (_c = projectNodes[node]).name) !== null && _b !== void 0 ? _b : (_c.name = node);
+                    mergeProjectConfigurationIntoRootMap(projectRootMap, projectNodes[node], file);
                 }
                 Object.assign(externalNodes, pluginExternalNodes);
             }
         }
     }
-    return { projects, externalNodes };
+    return {
+        projects: readProjectConfigurationsFromRootMap(projectRootMap),
+        externalNodes,
+    };
 }
 exports.buildProjectsConfigurationsFromProjectPathsAndPlugins = buildProjectsConfigurationsFromProjectPathsAndPlugins;
+function readProjectConfigurationsFromRootMap(projectRootMap) {
+    var _a;
+    const projects = {};
+    // If there are projects that have the same name, that is an error.
+    // This object tracks name -> (all roots of projects with that name)
+    // to provide better error messaging.
+    const errors = new Map();
+    for (const [root, configuration] of projectRootMap.entries()) {
+        if (!configuration.name) {
+            throw new Error(`Project at ${root} has no name provided.`);
+        }
+        else if (configuration.name in projects) {
+            let rootErrors = (_a = errors.get(configuration.name)) !== null && _a !== void 0 ? _a : [
+                projects[configuration.name].root,
+            ];
+            rootErrors.push(root);
+            errors.set(configuration.name, rootErrors);
+        }
+        else {
+            projects[configuration.name] = configuration;
+        }
+    }
+    if (errors.size > 0) {
+        throw new Error([
+            `The following projects are defined in multiple locations:`,
+            ...Array.from(errors.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'));
+    }
+    return projects;
+}
+exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
 function mergeTargetConfigurations(projectConfiguration, target, targetDefaults) {
     var _a;
     const targetConfiguration = (_a = projectConfiguration.targets) === null || _a === void 0 ? void 0 : _a[target];

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -66,8 +66,12 @@ function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson)
     var _a;
     return tslib_1.__awaiter(this, void 0, void 0, function* () {
         const plugins = yield (0, nx_plugin_1.loadNxPlugins)((_a = nxJson === null || nxJson === void 0 ? void 0 : nxJson.plugins) !== null && _a !== void 0 ? _a : [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
+        if ((0, angular_json_1.shouldMergeAngularProjects)(workspaceRoot, true) &&
+            !plugins.some((p) => p.name === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME)) {
+            plugins.push(angular_json_1.NxAngularJsonPlugin);
+        }
         const globs = configurationGlobs(workspaceRoot, plugins);
-        return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs, true);
+        return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs);
     });
 }
 exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
@@ -81,10 +85,10 @@ function retrieveProjectConfigurationsSync(workspaceRoot, nxJson) {
     return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs);
 }
 exports.retrieveProjectConfigurationsSync = retrieveProjectConfigurationsSync;
-function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs, includeProjectsFromAngularJson = false) {
+function _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins, globs) {
     const { getProjectConfigurations } = require('../../native');
     return getProjectConfigurations(workspaceRoot, globs, (configs) => {
-        const projectConfigurations = createProjectConfigurations(workspaceRoot, nxJson, configs, plugins, includeProjectsFromAngularJson);
+        const projectConfigurations = createProjectConfigurations(workspaceRoot, nxJson, configs, plugins);
         return {
             projectNodes: projectConfigurations.projects,
             externalNodes: projectConfigurations.externalNodes,
@@ -131,13 +135,10 @@ function buildAllWorkspaceFiles(projectFileMap, globalFiles) {
     perf_hooks_1.performance.measure('get-all-workspace-files', 'get-all-workspace-files:start', 'get-all-workspace-files:end');
     return fileData;
 }
-function createProjectConfigurations(workspaceRoot, nxJson, configFiles, plugins, includeProjectsFromAngularJson = false) {
+function createProjectConfigurations(workspaceRoot, nxJson, configFiles, plugins) {
     perf_hooks_1.performance.mark('build-project-configs:start');
     const { projects, externalNodes } = (0, project_configuration_utils_1.buildProjectsConfigurationsFromProjectPathsAndPlugins)(nxJson, configFiles, plugins, workspaceRoot);
     let projectConfigurations = projects;
-    if ((0, angular_json_1.shouldMergeAngularProjects)(workspaceRoot, includeProjectsFromAngularJson)) {
-        projectConfigurations = (0, angular_json_1.mergeAngularJsonAndProjects)(projectConfigurations, workspaceRoot);
-    }
     perf_hooks_1.performance.mark('build-project-configs:end');
     perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
     return {

package/src/utils/nx-plugin.d.ts

@@ -8,7 +8,6 @@ import { ProjectGraphDependencyWithFile } from '../project-graph/project-graph-b
  * Context for {@link CreateNodesFunction}
  */
 export interface CreateNodesContext {
-    readonly projectsConfigurations: Record<string, ProjectConfiguration>;
     readonly nxJsonConfiguration: NxJsonConfiguration;
     readonly workspaceRoot: string;
 }

package/src/utils/nx-plugin.js

@@ -17,6 +17,7 @@ const installation_directory_1 = require("./installation-directory");
 const typescript_1 = require("../plugins/js/utils/typescript");
 const retrieve_workspace_files_1 = require("../project-graph/utils/retrieve-workspace-files");
 const globs_1 = require("./globs");
+const angular_json_1 = require("../adapter/angular-json");
 tslib_1.__exportStar(require("./nx-plugin.deprecated"), exports);
 // Short lived cache (cleared between cmd runs)
 // holding resolved nx plugin objects.
@@ -113,6 +114,9 @@ function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequir
         const jsPlugin = yield Promise.resolve().then(() => require('../plugins/js'));
         jsPlugin.name = 'nx-js-graph-plugin';
         result.push(jsPlugin);
+        if ((0, angular_json_1.shouldMergeAngularProjects)(root, false)) {
+            result.push(angular_json_1.NxAngularJsonPlugin);
+        }
         plugins !== null && plugins !== void 0 ? plugins : (plugins = []);
         for (const plugin of plugins) {
             result.push(yield loadNxPluginAsync(plugin, paths, root));
@@ -122,6 +126,9 @@ function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequir
 }
 exports.loadNxPlugins = loadNxPlugins;
 function ensurePluginIsV2(plugin) {
+    if (isNxPluginV2(plugin)) {
+        return plugin;
+    }
     if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
         return Object.assign(Object.assign({}, plugin), { createNodes: [
                 `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,

package/src/utils/package-json.d.ts

@@ -66,6 +66,7 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
     packageGroup?: ArrayPackageGroup;
 };
 export declare function buildTargetFromScript(script: string, nx: NxProjectPackageJsonConfiguration): TargetConfiguration;
+export declare function readTargetsFromPackageJson({ scripts, nx }: PackageJson): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/utils/package-json.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readModulePackageJson = exports.readModulePackageJsonWithoutFallbacks = exports.buildTargetFromScript = exports.readNxMigrateConfig = exports.normalizePackageGroup = void 0;
+exports.readModulePackageJson = exports.readModulePackageJsonWithoutFallbacks = exports.readTargetsFromPackageJson = exports.buildTargetFromScript = exports.readNxMigrateConfig = exports.normalizePackageGroup = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const fileutils_1 = require("./fileutils");
@@ -35,6 +35,16 @@ function buildTargetFromScript(script, nx) {
     return Object.assign(Object.assign({}, nxTargetConfiguration), { executor: 'nx:run-script', options: Object.assign(Object.assign({}, (nxTargetConfiguration.options || {})), { script }) });
 }
 exports.buildTargetFromScript = buildTargetFromScript;
+function readTargetsFromPackageJson({ scripts, nx }) {
+    const res = {};
+    Object.keys(scripts || {}).forEach((script) => {
+        if (!(nx === null || nx === void 0 ? void 0 : nx.includedScripts) || (nx === null || nx === void 0 ? void 0 : nx.includedScripts.includes(script))) {
+            res[script] = buildTargetFromScript(script, nx);
+        }
+    });
+    return res;
+}
+exports.readTargetsFromPackageJson = readTargetsFromPackageJson;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/utils/package-manager.js

@@ -47,9 +47,7 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
             const yarnVersion = getPackageManagerVersion('yarn', root);
             const useBerry = (0, semver_1.gte)(yarnVersion, '2.0.0');
             return {
-                preInstall: useBerry
-                    ? 'yarn set version stable'
-                    : 'yarn set version classic',
+                preInstall: `yarn set version ${yarnVersion}`,
                 install: 'yarn',
                 ciInstall: useBerry
                     ? 'yarn install --immutable'

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

@@ -1,8 +1,6 @@
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
-import { TargetConfiguration } from '../config/workspace-json-project-json';
 export declare function projectHasTarget(project: ProjectGraphProjectNode, target: string): boolean;
 export declare function projectHasTargetAndConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string): any;
-export declare function mergeNpmScriptsWithTargets(projectRoot: string, targets: any): Record<string, TargetConfiguration>;
 export declare function getSourceDirOfDependentProjects(projectName: string, projectGraph?: ProjectGraph): [projectDirs: string[], warnings: string[]];
 /**
  * Find all internal project dependencies.

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

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.findAllProjectNodeDependencies = exports.getSourceDirOfDependentProjects = exports.mergeNpmScriptsWithTargets = exports.projectHasTargetAndConfiguration = exports.projectHasTarget = void 0;
-const package_json_1 = require("./package-json");
-const path_1 = require("path");
-const fileutils_1 = require("./fileutils");
+exports.findAllProjectNodeDependencies = exports.getSourceDirOfDependentProjects = exports.projectHasTargetAndConfiguration = exports.projectHasTarget = void 0;
 const project_graph_1 = require("../project-graph/project-graph");
 function projectHasTarget(project, target) {
     return !!(project.data &&
@@ -17,23 +14,6 @@ function projectHasTargetAndConfiguration(project, target, configuration) {
         project.data.targets[target].configurations[configuration]);
 }
 exports.projectHasTargetAndConfiguration = projectHasTargetAndConfiguration;
-function mergeNpmScriptsWithTargets(projectRoot, targets) {
-    try {
-        const { scripts, nx } = (0, fileutils_1.readJsonFile)((0, path_1.join)(projectRoot, 'package.json'));
-        const res = {};
-        // handle no scripts
-        Object.keys(scripts || {}).forEach((script) => {
-            if (!(nx === null || nx === void 0 ? void 0 : nx.includedScripts) || (nx === null || nx === void 0 ? void 0 : nx.includedScripts.includes(script))) {
-                res[script] = (0, package_json_1.buildTargetFromScript)(script, nx);
-            }
-        });
-        return Object.assign(Object.assign({}, res), (targets || {}));
-    }
-    catch (e) {
-        return targets;
-    }
-}
-exports.mergeNpmScriptsWithTargets = mergeNpmScriptsWithTargets;
 function getSourceDirOfDependentProjects(projectName, projectGraph = (0, project_graph_1.readCachedProjectGraph)()) {
     if (!projectGraph.nodes[projectName]) {
         throw new Error(`Couldn't find project "${projectName}" in this Nx workspace`);

package/src/utils/testing/mock-fs.js

@@ -10,3 +10,15 @@ jest.mock('fs', () => {
             }
         } });
 });
+// @ts-ignore
+jest.mock('node:fs', () => {
+    const mockFs = require('memfs').fs;
+    return Object.assign(Object.assign({}, mockFs), { existsSync(path) {
+            if (path.endsWith('.node')) {
+                return true;
+            }
+            else {
+                return mockFs.existsSync(path);
+            }
+        } });
+});