nx 23.3.0-beta.5 → 23.3.0-beta.7

package/dist/src/native/transform-objects.js

@@ -1,7 +1,52 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformProjectGraphForRust = transformProjectGraphForRust;
+exports.transformProjectGraphForLocators = transformProjectGraphForLocators;
+exports.toRustProjectGraph = toRustProjectGraph;
+const index_1 = require("./index");
+/**
+ * Keyed by graph identity, but weak so a replaced graph is collectable. A run's
+ * hasher reuses what affected's planner already copied.
+ */
+const transferred = new WeakMap();
+/** The graph copied into Rust, once per graph. */
 function transformProjectGraphForRust(graph) {
+    let ref = transferred.get(graph);
+    if (!ref) {
+        ref = (0, index_1.transferProjectGraph)(toRustProjectGraph(graph));
+        transferred.set(graph, ref);
+    }
+    return ref;
+}
+/** Per graph like `transferred`: `nx release` runs the locators once per commit. */
+const transferredForLocators = new WeakMap();
+/**
+ * Only what the touched-project locators read: project roots, named inputs and
+ * target inputs. Copying target options and every edge costs several times
+ * what the locators themselves do on a large workspace.
+ */
+function transformProjectGraphForLocators(graph) {
+    let ref = transferredForLocators.get(graph);
+    if (!ref) {
+        const nodes = {};
+        for (const [name, node] of Object.entries(graph.nodes)) {
+            const targets = {};
+            for (const [target, config] of Object.entries(node.data.targets ?? {})) {
+                targets[target] = { inputs: config.inputs };
+            }
+            nodes[name] = {
+                root: node.data.root,
+                namedInputs: node.data.namedInputs,
+                targets,
+            };
+        }
+        ref = (0, index_1.transferProjectGraph)({ nodes, externalNodes: {}, dependencies: {} });
+        transferredForLocators.set(graph, ref);
+    }
+    return ref;
+}
+/** The graph in Rust's shape, still a JS object. Uncached, so safe to edit. */
+function toRustProjectGraph(graph) {
     const dependencies = {};
     const nodes = {};
     const externalNodes = {};
@@ -32,6 +77,7 @@ function transformProjectGraphForRust(graph) {
     }
     for (const [projectName, externalNode] of Object.entries(graph.externalNodes ?? {})) {
         externalNodes[projectName] = {
+            type: externalNode.type,
             packageName: externalNode.data.packageName,
             hash: externalNode.data.hash,
             version: externalNode.data.version,

package/dist/src/nx-cloud/update-manager.d.ts

@@ -1,4 +1,5 @@
 import type { CloudTaskRunnerOptions } from './nx-cloud-tasks-runner-shell';
+import type { ReadIoSnapshotsOptions, ReadIoSnapshotsResult } from '../io-snapshots/fetch';
 import { TasksRunner } from '../tasks-runner/tasks-runner';
 import { RemoteCacheV2 } from '../tasks-runner/default-tasks-runner';
 export declare class NxCloudEnterpriseOutdatedError extends Error {
@@ -12,6 +13,8 @@ export interface NxCloudClient {
     commands: Record<string, () => Promise<void>>;
     nxCloudTasksRunner: TasksRunner<CloudTaskRunnerOptions>;
     getRemoteCache: () => RemoteCacheV2;
+    /** Clients that expose I/O snapshots; see `fetchIoSnapshots`. */
+    readIoSnapshots?: (options: ReadIoSnapshotsOptions) => Promise<ReadIoSnapshotsResult | null>;
 }
 export declare function verifyOrUpdateNxCloudClient(options?: {
     url?: string;

package/dist/src/plugins/js/index.js

@@ -18,12 +18,16 @@ const lock_file_1 = require("./lock-file/lock-file");
 const build_dependencies_1 = require("./project-graph/build-dependencies/build-dependencies");
 const config_1 = require("./utils/config");
 exports.name = 'nx/js/dependencies-and-lockfile';
-// Separate in-memory caches
-let cachedExternalNodes;
+// An install can rewrite the lockfile between createNodes and
+// createDependencies, so both parse the one createNodes read.
+let cachedLockFile;
 let cachedKeyMap;
 exports.createNodes = [
     (0, globs_1.combineGlobPatterns)(lock_file_1.LOCKFILES),
     (files, _, context) => {
+        // A long-lived process must not reuse a lockfile this computation skipped.
+        cachedLockFile = undefined;
+        cachedKeyMap = undefined;
         return (0, plugins_1.createNodesFromFiles)(internalCreateNodes, files, _, context);
     },
 ];
@@ -42,41 +46,45 @@ function internalCreateNodes(lockFile, _, context) {
         ? (0, fs_1.readFileSync)(lockFilePath, 'utf-8')
         : (0, bun_parser_1.readBunLockFile)(lockFilePath);
     const lockFileHash = getLockFileHash(lockFileContents);
-    if (!lockFileNeedsReprocessing(lockFileHash, externalNodesHashFile)) {
-        const { nodes, keyMap } = readCachedExternalNodes();
-        cachedExternalNodes = nodes;
-        cachedKeyMap = keyMap;
+    cachedLockFile = { packageManager, lockFile, lockFileContents, lockFileHash };
+    const cached = readCache(externalNodesCache, lockFileHash);
+    if (cached) {
+        cachedKeyMap = deserializeKeyMap(cached.keyMap, cached.nodes);
         return {
-            externalNodes: nodes,
+            externalNodes: cached.nodes,
         };
     }
-    const { nodes: externalNodes, keyMap } = (0, lock_file_1.getLockFileNodes)(packageManager, lockFileContents, lockFileHash, context);
-    cachedExternalNodes = externalNodes;
+    const { nodes: externalNodes, keyMap } = (0, lock_file_1.getLockFileNodes)(packageManager, lockFile, lockFileContents, lockFileHash, context);
     cachedKeyMap = keyMap;
-    writeExternalNodesCache(lockFileHash, externalNodes, keyMap);
+    writeCache(externalNodesCache, lockFileHash, {
+        nodes: externalNodes,
+        keyMap: serializeKeyMap(keyMap),
+    });
     return {
         externalNodes,
     };
 }
 const createDependencies = (_, ctx) => {
     const pluginConfig = (0, config_1.jsPluginConfig)(ctx.nxJsonConfiguration);
-    const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
     let lockfileDependencies = [];
     // lockfile may not exist yet
     if (pluginConfig.analyzeLockfile &&
-        (0, lock_file_1.lockFileExists)(packageManager) &&
-        cachedExternalNodes) {
-        const lockFilePath = (0, path_1.join)(workspace_root_1.workspaceRoot, (0, lock_file_1.getLockFileName)(packageManager));
-        const lockFileContents = packageManager !== 'bun'
-            ? (0, fs_1.readFileSync)(lockFilePath, 'utf-8')
-            : (0, bun_parser_1.readBunLockFile)(lockFilePath);
-        const lockFileHash = getLockFileHash(lockFileContents);
-        if (!lockFileNeedsReprocessing(lockFileHash, dependenciesHashFile)) {
-            lockfileDependencies = readCachedDependencies();
+        cachedLockFile &&
+        (0, lock_file_1.lockFileExists)(cachedLockFile.packageManager)) {
+        const { packageManager, lockFile, lockFileContents, lockFileHash } = cachedLockFile;
+        // Cached dependencies name their external nodes, and those names also
+        // depend on node_modules hoisting.
+        const dependenciesHash = (0, file_hasher_1.hashArray)([
+            lockFileHash,
+            ...Object.keys(ctx.externalNodes),
+        ]);
+        const cachedDependencies = readCache(dependenciesCache, dependenciesHash);
+        if (cachedDependencies) {
+            lockfileDependencies = cachedDependencies;
         }
         else {
-            lockfileDependencies = (0, lock_file_1.getLockFileDependencies)(packageManager, lockFileContents, lockFileHash, ctx, cachedKeyMap);
-            writeDependenciesCache(lockFileHash, lockfileDependencies);
+            lockfileDependencies = (0, lock_file_1.getLockFileDependencies)(packageManager, lockFile, lockFileContents, lockFileHash, ctx, cachedKeyMap);
+            writeCache(dependenciesCache, dependenciesHash, lockfileDependencies);
         }
     }
     perf_hooks_1.performance.mark('build typescript dependencies - start');
@@ -107,7 +115,7 @@ function serializeKeyMap(keyMap) {
     }
     return serialized;
 }
-// Deserialize keyMap from JSON format using ctx.externalNodes
+// Deserialize keyMap from JSON format
 function deserializeKeyMap(serialized, externalNodes) {
     const keyMap = new Map();
     for (const [key, value] of Object.entries(serialized)) {
@@ -131,47 +139,24 @@ function deserializeKeyMap(serialized, externalNodes) {
     }
     return keyMap;
 }
-function lockFileNeedsReprocessing(lockHash, hashFilePath) {
+function readCache(path, key) {
     try {
-        return (0, fs_1.readFileSync)(hashFilePath).toString() !== lockHash;
+        const cache = JSON.parse((0, fs_1.readFileSync)(path, 'utf-8'));
+        return cache.key === key ? cache.data : undefined;
     }
     catch {
-        return true;
-    }
-}
-// External nodes cache functions
-function writeExternalNodesCache(hash, nodes, keyMap) {
-    const serializedKeyMap = serializeKeyMap(keyMap);
-    const cacheData = { nodes, keyMap: serializedKeyMap };
-    const content = safeStringify(cacheData);
-    if (content === undefined) {
-        logger_1.logger.warn(`Failed to serialize external nodes cache. Skipping cache write.`);
-        tryRemoveFile(externalNodesCache);
-        tryRemoveFile(externalNodesHashFile);
-        return;
-    }
-    (0, plugin_cache_utils_1.safeWriteFileCache)(externalNodesCache, content);
-    if ((0, fs_1.existsSync)(externalNodesCache)) {
-        (0, plugin_cache_utils_1.safeWriteFileCache)(externalNodesHashFile, hash);
+        // Another process can be mid-write, so an unreadable cache is a miss.
+        return undefined;
     }
 }
-function readCachedExternalNodes() {
-    const { nodes, keyMap } = JSON.parse((0, fs_1.readFileSync)(externalNodesCache, 'utf-8'));
-    return { nodes, keyMap: deserializeKeyMap(keyMap, nodes) };
-}
-// Dependencies cache functions
-function writeDependenciesCache(hash, dependencies) {
-    const content = safeStringify(dependencies);
+function writeCache(path, key, data) {
+    const content = safeStringify({ key, data });
     if (content === undefined) {
-        logger_1.logger.warn(`Failed to serialize dependencies cache. Skipping cache write.`);
-        tryRemoveFile(dependenciesCache);
-        tryRemoveFile(dependenciesHashFile);
+        logger_1.logger.warn(`Failed to serialize ${path}. Skipping cache write.`);
+        tryRemoveFile(path);
         return;
     }
-    (0, plugin_cache_utils_1.safeWriteFileCache)(dependenciesCache, content);
-    if ((0, fs_1.existsSync)(dependenciesCache)) {
-        (0, plugin_cache_utils_1.safeWriteFileCache)(dependenciesHashFile, hash);
-    }
+    (0, plugin_cache_utils_1.safeWriteFileCache)(path, content);
 }
 function safeStringify(data) {
     try {
@@ -191,11 +176,7 @@ function tryRemoveFile(path) {
         // Best effort
     }
 }
-function readCachedDependencies() {
-    return JSON.parse((0, fs_1.readFileSync)(dependenciesCache).toString());
-}
-// Cache file paths
-const externalNodesHashFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'lockfile-nodes.hash');
-const dependenciesHashFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'lockfile-dependencies.hash');
-const externalNodesCache = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'parsed-lock-file.nodes.json');
-const dependenciesCache = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'parsed-lock-file.dependencies.json');
+// Each cache file holds its key, so key and data come from one write.
+// Older Nx versions read other names with a hash file; keep these distinct.
+const externalNodesCache = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'lockfile-nodes.json');
+const dependenciesCache = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'lockfile-dependencies.json');

package/dist/src/plugins/js/lock-file/lock-file.d.ts

@@ -10,9 +10,9 @@ import { PackageManager } from '../../../utils/package-manager';
 export declare const LOCKFILES: string[];
 export declare const AUTO_AFFECTED_LOCK_FILES: readonly ["yarn.lock", "package-lock.json", "pnpm-lock.yaml", "pnpm-lock.yml", "bun.lockb", "bun.lock"];
 /**
- * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ * Parses the lockfile into external nodes, plus the keyMap that getLockFileDependencies reads.
  */
-export declare function getLockFileNodes(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateNodesContext): {
+export declare function getLockFileNodes(packageManager: PackageManager, lockFile: string, contents: string, lockFileHash: string, context: CreateNodesContext): {
     nodes: Record<string, ProjectGraphExternalNode>;
     keyMap: Map<string, any>;
 };
@@ -21,9 +21,9 @@ export declare function getLockFileNodesForName(lockFile: string, contents: stri
     keyMap: Map<string, any>;
 };
 /**
- * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ * Parses the lockfile into dependencies between external nodes.
  */
-export declare function getLockFileDependencies(packageManager: PackageManager, contents: string, lockFileHash: string, context: CreateDependenciesContext, keyMap: Map<string, any>): RawProjectGraphDependency[];
+export declare function getLockFileDependencies(packageManager: PackageManager, lockFile: string, contents: string, lockFileHash: string, context: CreateDependenciesContext, keyMap: Map<string, any>): RawProjectGraphDependency[];
 export declare function lockFileExists(packageManager: PackageManager): boolean;
 /**
  * Returns lock file name based on the detected package manager in the root

package/dist/src/plugins/js/lock-file/lock-file.js

@@ -54,14 +54,14 @@ const PNPM_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot, PNP
 const BUN_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot, bun_parser_1.BUN_LOCK_FILE);
 const BUN_TEXT_LOCK_PATH = (0, node_path_1.join)(workspace_root_1.workspaceRoot, bun_parser_1.BUN_TEXT_LOCK_FILE);
 /**
- * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ * Parses the lockfile into external nodes, plus the keyMap that getLockFileDependencies reads.
  */
-function getLockFileNodes(packageManager, contents, lockFileHash, context) {
+function getLockFileNodes(packageManager, lockFile, contents, lockFileHash, context) {
     try {
         const packageJson = packageManager === 'yarn' || packageManager === 'bun'
             ? (0, fileutils_1.readJsonFile)((0, node_path_1.join)(context.workspaceRoot, 'package.json'))
             : undefined;
-        return getLockFileNodesForName(getLockFileName(packageManager), contents, lockFileHash, packageJson);
+        return getLockFileNodesForName(lockFile, contents, lockFileHash, packageJson);
     }
     catch (e) {
         if (!isPostInstallProcess()) {
@@ -94,9 +94,9 @@ function getLockFileNodesForName(lockFile, contents, lockFileHash, packageJson)
     throw new Error(`Unknown lock file: ${lockFile}`);
 }
 /**
- * Parses lock file and maps dependencies and metadata to {@link LockFileGraph}
+ * Parses the lockfile into dependencies between external nodes.
  */
-function getLockFileDependencies(packageManager, contents, lockFileHash, context, keyMap) {
+function getLockFileDependencies(packageManager, lockFile, contents, lockFileHash, context, keyMap) {
     try {
         if (packageManager === 'yarn') {
             return (0, yarn_parser_1.getYarnLockfileDependencies)(contents, lockFileHash, context, keyMap);
@@ -108,8 +108,7 @@ function getLockFileDependencies(packageManager, contents, lockFileHash, context
             return (0, npm_parser_1.getNpmLockfileDependencies)(contents, lockFileHash, context, keyMap);
         }
         if (packageManager === 'bun') {
-            const lockFilePath = getLockFilePath(packageManager);
-            if (lockFilePath.endsWith(bun_parser_1.BUN_TEXT_LOCK_FILE)) {
+            if (lockFile === bun_parser_1.BUN_TEXT_LOCK_FILE) {
                 // Bun parser doesn't use keyMap
                 return (0, bun_parser_1.getBunTextLockfileDependencies)(contents, lockFileHash, context);
             }

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.d.ts

@@ -1,3 +1,11 @@
-import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
-import { LockFileChange, WholeFileChange } from '../../../../project-graph/file-utils';
+import { DependencyChanges, TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { FileChange, LockFileChange, WholeFileChange } from '../../../../project-graph/file-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../../../config/project-graph';
+import { NxJsonConfiguration } from '../../../../config/nx-json';
+import { PackageJson } from '../../../../utils/package-json';
 export declare const getTouchedProjectsFromLockFile: TouchedProjectLocator<WholeFileChange | LockFileChange>;
+/**
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, rather than the projects depending on them.
+ */
+export declare function lockFileDependencyChanges(fileChanges: FileChange<WholeFileChange | LockFileChange>[], projectGraphNodes: Record<string, ProjectGraphProjectNode>, nxJson: NxJsonConfiguration, packageJson: PackageJson | undefined, projectGraph: ProjectGraph): DependencyChanges;

package/dist/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedProjectsFromLockFile = void 0;
+exports.lockFileDependencyChanges = lockFileDependencyChanges;
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const config_1 = require("../../utils/config");
 const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
@@ -9,61 +10,82 @@ const output_1 = require("../../../../utils/output");
 const lock_file_1 = require("../../lock-file/lock-file");
 const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes, nxJson, packageJson, projectGraph) => {
     const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
-    const changedLockFile = fileChanges.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file));
+    const changedLockFile = findChangedLockFile(fileChanges);
+    const allProjectNames = Object.values(projectGraphNodes).map((p) => p.name);
     if (projectsAffectedByDependencyUpdates === 'auto') {
-        return getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson);
+        if (!changedLockFile) {
+            return [];
+        }
+        // External node names, which the reverse walk in filterAffected carries
+        // back to the projects depending on them.
+        return (changedExternalNodes(changedLockFile, projectGraph, packageJson) ??
+            allProjectNames);
     }
     else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
         return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
     }
-    if (changedLockFile) {
-        return Object.values(projectGraphNodes).map((p) => p.name);
-    }
-    return [];
+    return changedLockFile ? allProjectNames : [];
 };
 exports.getTouchedProjectsFromLockFile = getTouchedProjectsFromLockFile;
 /**
- * In auto mode, parse the lock file at the base and head revisions
- * using Nx's existing lock file parsers, then diff the resulting
- * external-node maps to determine which packages actually changed.
- *
- * Returns external node names (e.g. "npm:lodash@4.17.21") so the
- * graph reversal in filterAffected can walk back to workspace projects.
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, rather than the projects depending on them.
  */
-function getAutoAffected(changedLockFile, projectGraphNodes, projectGraph, packageJson) {
-    const allProjectNames = Object.values(projectGraphNodes).map((p) => p.name);
+function lockFileDependencyChanges(fileChanges, projectGraphNodes, nxJson, packageJson, projectGraph) {
+    const none = {
+        externals: [],
+        changedExternalTypes: [],
+        projects: [],
+    };
+    const changedLockFile = findChangedLockFile(fileChanges);
     if (!changedLockFile) {
-        return [];
+        return none;
+    }
+    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    if (Array.isArray(projectsAffectedByDependencyUpdates)) {
+        return {
+            ...none,
+            projects: (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes),
+        };
     }
+    const externals = projectsAffectedByDependencyUpdates === 'auto'
+        ? changedExternalNodes(changedLockFile, projectGraph, packageJson)
+        : null;
+    return externals
+        ? { ...none, externals }
+        : { ...none, changedExternalTypes: ['npm'] };
+}
+function findChangedLockFile(fileChanges) {
+    return fileChanges.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file));
+}
+/**
+ * Diffs the lock file's base and head revisions with the parsers the project
+ * graph is built from, and names the external nodes whose package changed.
+ *
+ * Null when the diff cannot be pinned to packages: a WholeFileChange (a
+ * revision could not be read), a parse failure, or a changed package with no
+ * external node in the head graph.
+ */
+function changedExternalNodes(changedLockFile, projectGraph, packageJson) {
     const changes = changedLockFile.getChanges();
-    // A WholeFileChange means we were unable to read both revisions of
-    // the lock file (e.g. missing base revision, git error). Fall back
-    // to marking all projects affected.
     if (!changes.every(file_utils_1.isLockFileChange)) {
-        return allProjectNames;
+        return null;
     }
     const changedPackageNames = getChangedPackageNames(changedLockFile.file, changes, packageJson);
     if (changedPackageNames === null) {
-        return allProjectNames;
+        return null;
     }
     if (changedPackageNames.size === 0) {
         return [];
     }
-    // Look up the changed packages in the project graph's external nodes
-    // and return the external node names. The graph reversal in
-    // filterAffected walks from these nodes to workspace projects.
     const { touchedNodeNames, missingPackageNames } = findExternalNodesByPackageName(changedPackageNames, projectGraph.externalNodes ?? {});
-    if (missingPackageNames.size > 0) {
-        return allProjectNames;
-    }
-    return touchedNodeNames;
+    return missingPackageNames.size > 0 ? null : touchedNodeNames;
 }
 /**
  * Parse the base and head revisions of the lock file with Nx's
  * existing parsers and diff the resulting package -> version maps.
  *
- * Returns the set of changed package names, or null if parsing
- * failed (in which case the caller should fall back to all projects).
+ * Returns the set of changed package names, or null if parsing failed.
  */
 function getChangedPackageNames(file, changes, packageJson) {
     try {

package/dist/src/plugins/js/project-graph/affected/npm-packages.d.ts

@@ -1,4 +1,12 @@
-import { WholeFileChange } from '../../../../project-graph/file-utils';
+import { FileChange, WholeFileChange } from '../../../../project-graph/file-utils';
 import { JsonChange } from '../../../../utils/json-diff';
-import { TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { DependencyChanges, TouchedProjectLocator } from '../../../../project-graph/affected/affected-project-graph-models';
+import { ProjectGraph } from '../../../../config/project-graph';
+import { NxJsonConfiguration } from '../../../../config/nx-json';
 export declare const getTouchedNpmPackages: TouchedProjectLocator<WholeFileChange | JsonChange>;
+/**
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, and the workspace projects the root
+ * package.json depends on directly.
+ */
+export declare function packageJsonDependencyChanges(touchedFiles: FileChange<WholeFileChange | JsonChange>[], nxJson: NxJsonConfiguration, projectGraph: ProjectGraph): DependencyChanges;

package/dist/src/plugins/js/project-graph/affected/npm-packages.js

@@ -1,11 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedNpmPackages = void 0;
+exports.packageJsonDependencyChanges = packageJsonDependencyChanges;
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const json_diff_1 = require("../../../../utils/json-diff");
 const logger_1 = require("../../../../utils/logger");
 const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
-const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGraph) => {
+const getTouchedNpmPackages = (touchedFiles, _nodes, nxJson, _packageJson, projectGraph) => touchedNpmPackages(touchedFiles, nxJson, projectGraph) ??
+    Object.keys(projectGraph.nodes);
+exports.getTouchedNpmPackages = getTouchedNpmPackages;
+/**
+ * The same change as task selection consumes it: the packages that moved,
+ * which a plan names as `External`, and the workspace projects the root
+ * package.json depends on directly.
+ */
+function packageJsonDependencyChanges(touchedFiles, nxJson, projectGraph) {
+    const touched = touchedNpmPackages(touchedFiles, nxJson, projectGraph);
+    if (touched === null) {
+        return { externals: [], changedExternalTypes: ['npm'], projects: [] };
+    }
+    return {
+        externals: touched.filter((name) => name in projectGraph.externalNodes),
+        changedExternalTypes: [],
+        projects: touched.filter((name) => name in projectGraph.nodes),
+    };
+}
+/**
+ * External nodes and workspace projects the root package.json change names,
+ * or null when it cannot be pinned to them: a removed dependency, a global
+ * package, or an override selector matching nothing in the graph.
+ */
+function touchedNpmPackages(touchedFiles, nxJson, projectGraph) {
     const packageJsonChange = touchedFiles.find((f) => f.file === 'package.json');
     if (!packageJsonChange)
         return [];
@@ -19,10 +44,8 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
         if ((0, json_diff_1.isJsonChange)(c) &&
             (c.path[0] === 'dependencies' || c.path[0] === 'devDependencies') &&
             c.path.length === 2) {
-            // A package was deleted so mark all workspace projects as touched.
             if (c.type === json_diff_1.JsonDiffType.Deleted) {
-                touched = Object.keys(projectGraph.nodes);
-                break;
+                return null;
             }
             else {
                 let npmPackage = npmPackages.find((pkg) => pkg.data.packageName === c.path[1]);
@@ -45,7 +68,7 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
                 }
                 if ('packageName' in npmPackage.data) {
                     if (globalPackages.has(npmPackage.data.packageName)) {
-                        return Object.keys(projectGraph.nodes);
+                        return null;
                     }
                 }
             }
@@ -59,13 +82,12 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
                 continue;
             packagesByName ??= groupPackagesByName(npmPackages);
             const matchingNpmPackages = findPackagesForSelector(packageSelector, packagesByName, c.path[0] === 'pnpm');
-            // An unresolved selector can still target a transitive dependency,
-            // so fall back to marking every project affected.
+            // An unresolved selector can still target a transitive dependency.
             if (!matchingNpmPackages.length) {
-                return Object.keys(projectGraph.nodes);
+                return null;
             }
             if (matchingNpmPackages.some((pkg) => globalPackages.has(pkg.data.packageName))) {
-                return Object.keys(projectGraph.nodes);
+                return null;
             }
             touched.push(...matchingNpmPackages.map((pkg) => pkg.name));
         }
@@ -79,8 +101,7 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
         logger_1.logger.warn(`The affected projects might have not been identified properly. The package(s) ${missingTouchedNpmPackages.join(', ')} were not found. Please open an issue in GitHub including the package.json file.`);
     }
     return [...new Set(touched)];
-};
-exports.getTouchedNpmPackages = getTouchedNpmPackages;
+}
 function getPackageSelector(change) {
     if (typeof change.value.lhs !== 'string' &&
         typeof change.value.rhs !== 'string') {

package/dist/src/project-graph/affected/affected-project-graph-models.d.ts

@@ -6,6 +6,20 @@ export interface AffectedProjectGraphContext {
     nxJson: NxJsonConfiguration<any>;
     touchedProjects: string[];
 }
+/**
+ * What a lockfile or package.json change moved, before it is projected onto
+ * projects (the reverse walk) or tasks (matched against each plan's externals).
+ */
+export interface DependencyChanges {
+    /** External node names whose version or integrity moved. */
+    externals: string[];
+    /** Ecosystems whose manifest changed without the change being pinnable to
+     * packages, so every node of that type counts as moved. A locator names the
+     * ecosystem it reads, since a change to one cannot move another's nodes. */
+    changedExternalTypes: string[];
+    /** Workspace projects the change names outright. */
+    projects: string[];
+}
 export interface TouchedProjectLocator<T extends Change = Change> {
     (fileChanges: FileChange<T>[], projectGraphNodes?: Record<string, ProjectGraphProjectNode>, nxJson?: NxJsonConfiguration<any>, packageJson?: any, projectGraph?: ProjectGraph, projectDeletionAffectsAllProjects?: boolean): string[] | Promise<string[]>;
 }

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

@@ -2,27 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterAffected = filterAffected;
 const file_utils_1 = require("../file-utils");
-const workspace_projects_1 = require("./locators/workspace-projects");
-const touched_projects_1 = require("../../plugins/js/project-graph/affected/touched-projects");
 const operators_1 = require("../operators");
 const configuration_1 = require("../../config/configuration");
-const project_glob_changes_1 = require("./locators/project-glob-changes");
+const affected_projects_1 = require("./affected-projects");
 async function filterAffected(graph, touchedFiles, nxJson = (0, configuration_1.readNxJson)(), packageJson = (0, file_utils_1.readPackageJson)(), projectDeletionAffectsAllProjects = true) {
-    // Additional affected logic should be in this array.
-    const touchedProjectLocators = [
-        workspace_projects_1.getTouchedProjects,
-        workspace_projects_1.getImplicitlyTouchedProjects,
-        project_glob_changes_1.getTouchedProjectsFromProjectGlobChanges,
-        touched_projects_1.getTouchedProjects,
-    ];
-    const touchedProjects = [];
-    for (const locator of touchedProjectLocators) {
-        performance.mark(locator.name + ':start');
-        const projects = await locator(touchedFiles, graph.nodes, nxJson, packageJson, graph, projectDeletionAffectsAllProjects);
-        performance.mark(locator.name + ':end');
-        performance.measure(locator.name, locator.name + ':start', locator.name + ':end');
-        touchedProjects.push(...projects);
-    }
+    performance.mark('locateTouchedProjects:start');
+    const touchedProjects = await (0, affected_projects_1.runTouchedProjectLocators)(graph, touchedFiles, nxJson, packageJson, projectDeletionAffectsAllProjects);
+    performance.mark('locateTouchedProjects:end');
+    performance.measure('locateTouchedProjects', 'locateTouchedProjects:start', 'locateTouchedProjects:end');
     return filterAffectedProjects(graph, {
         projectGraphNodes: graph.nodes,
         nxJson,

package/dist/src/project-graph/affected/affected-projects.d.ts

@@ -0,0 +1,7 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectGraph } from '../../config/project-graph';
+import { FileChange } from '../file-utils';
+/** Runs every locator and returns what each one marked, duplicates included. */
+export declare function runTouchedProjectLocators(graph: ProjectGraph, touchedFiles: FileChange[], nxJson: NxJsonConfiguration, packageJson?: any, projectDeletionAffectsAllProjects?: boolean): Promise<string[]>;
+/** Resolved here because the native side takes the patterns, not the plugins. */
+export declare function getProjectGlobPatterns(nxJson: NxJsonConfiguration): Promise<string[]>;