@depup/nx 23.2.1-depup.8 → 23.3.0-depup.0

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/lock-file/pnpm-parser.js

@@ -663,7 +663,7 @@ function stringifyPnpmLockfile(graph, rootLockFileContent, packageJson, workspac
     }
     output.packages = (0, object_sort_1.sortObjectByKeys)(output.packages);
     stripStandaloneLockfileConfig(output);
-    return (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output);
+    return (0, pnpm_normalizer_1.joinPnpmLockfileDocuments)((0, pnpm_normalizer_1.extractEnvLockfileDocument)(rootLockFileContent), (0, pnpm_normalizer_1.stringifyToPnpmYaml)(output));
 }
 /**
  * Removes settings a standalone, pruned lockfile cannot satisfy on its own.

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

@@ -15,6 +15,8 @@ export declare function loadPnpmHoistedDepsDefinition(): any;
  */
 export declare function parseAndNormalizePnpmLockfile(content: string): Lockfile;
 export declare function extractMainLockfileDocument(content: string): string;
+export declare function extractEnvLockfileDocument(content: string): string | null;
+export declare function joinPnpmLockfileDocuments(envDocument: string | null, mainDocument: string): string;
 /**
  * Mapping and writing logic from pnpm lockfile `write` function
  */

package/dist/src/plugins/js/lock-file/utils/pnpm-normalizer.js

@@ -9,6 +9,8 @@ exports.usesLeadingDash = usesLeadingDash;
 exports.loadPnpmHoistedDepsDefinition = loadPnpmHoistedDepsDefinition;
 exports.parseAndNormalizePnpmLockfile = parseAndNormalizePnpmLockfile;
 exports.extractMainLockfileDocument = extractMainLockfileDocument;
+exports.extractEnvLockfileDocument = extractEnvLockfileDocument;
+exports.joinPnpmLockfileDocuments = joinPnpmLockfileDocuments;
 exports.stringifyToPnpmYaml = stringifyToPnpmYaml;
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
@@ -68,6 +70,26 @@ function extractMainLockfileDocument(content) {
     }
     return content.slice(separatorIndex + YAML_DOCUMENT_SEPARATOR.length);
 }
+// The package-manager document (`packageManagerDependencies`) must ship with a
+// pruned lockfile whenever the pruned manifest keeps `packageManager`: pnpm
+// refuses a frozen install when the pin is not recorded in the lockfile.
+function extractEnvLockfileDocument(content) {
+    content = content.replace(/\r\n/g, '\n');
+    if (!content.startsWith(YAML_DOCUMENT_START)) {
+        return null;
+    }
+    const separatorIndex = content.indexOf(YAML_DOCUMENT_SEPARATOR, YAML_DOCUMENT_START.length);
+    if (separatorIndex === -1) {
+        return null;
+    }
+    return content.slice(YAML_DOCUMENT_START.length, separatorIndex);
+}
+function joinPnpmLockfileDocuments(envDocument, mainDocument) {
+    if (envDocument === null) {
+        return mainDocument;
+    }
+    return `${YAML_DOCUMENT_START}${envDocument}${YAML_DOCUMENT_SEPARATOR}${mainDocument}`;
+}
 // https://github.com/pnpm/pnpm/blob/50e37072f42bcca6d393a74bed29f7f0e029805d/lockfile/lockfile-file/src/write.ts#L22
 const LOCKFILE_YAML_FORMAT = {
     blankLines: true,

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/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -416,17 +416,16 @@ class TargetProjectLocator {
         const packageJsonPath = (0, resolve_relative_to_dir_1.resolveRelativeToDir)((0, node_path_1.join)(packageName, 'package.json'), relativeToDir);
         if (packageJsonPath) {
             if (this.packageJsonResolutionCache.has(packageJsonPath)) {
-                return this.packageJsonResolutionCache.get(packageJsonPath);
+                const cached = this.packageJsonResolutionCache.get(packageJsonPath);
+                if (cached) {
+                    return cached;
+                }
             }
             const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
             if (parsedPackageJson.name && parsedPackageJson.version) {
                 this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
                 return parsedPackageJson;
             }
-            else {
-                this.packageJsonResolutionCache.set(packageJsonPath, null);
-                return null;
-            }
         }
         try {
             // Resolve the main entry point of the package
@@ -435,22 +434,27 @@ class TargetProjectLocator {
             while (dir !== (0, node_path_1.dirname)(dir)) {
                 const packageJsonPath = (0, node_path_1.join)(dir, 'package.json');
                 if (this.packageJsonResolutionCache.has(packageJsonPath)) {
-                    return this.packageJsonResolutionCache.get(packageJsonPath);
-                }
-                try {
-                    const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
-                    // Ensure the package.json contains the "name" and "version" fields
-                    if (parsedPackageJson.name && parsedPackageJson.version) {
-                        this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
-                        return parsedPackageJson;
+                    const cached = this.packageJsonResolutionCache.get(packageJsonPath);
+                    if (cached) {
+                        return cached;
                     }
-                    else {
+                    // Cached incomplete manifests are traversal points, not terminal misses.
+                }
+                else {
+                    try {
+                        const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+                        // Ensure the package.json contains the "name" and "version" fields
+                        if (parsedPackageJson.name && parsedPackageJson.version) {
+                            this.packageJsonResolutionCache.set(packageJsonPath, parsedPackageJson);
+                            return parsedPackageJson;
+                        }
+                        // A module-format stub without name/version: remember it and keep
+                        // traversing towards the real manifest.
                         this.packageJsonResolutionCache.set(packageJsonPath, null);
-                        return null;
                     }
-                }
-                catch {
-                    // Package.json is invalid, keep traversing
+                    catch {
+                        // Package.json is invalid, keep traversing
+                    }
                 }
                 dir = (0, node_path_1.dirname)(dir);
             }

package/dist/src/plugins/js/utils/register.js

@@ -24,6 +24,7 @@ exports.registerTsConfigPaths = registerTsConfigPaths;
 exports.getTsNodeCompilerOptions = getTsNodeCompilerOptions;
 const path_1 = require("path");
 const fs_1 = require("fs");
+const fileutils_1 = require("../../../utils/fileutils");
 const logger_1 = require("../../../utils/logger");
 const workspace_root_1 = require("../../../utils/workspace-root");
 const typescript_1 = require("./typescript");
@@ -846,6 +847,13 @@ function loadTsFile(filePath, tsConfigPath) {
     if (isInvokedByTsx) {
         return require(filePath);
     }
+    // Executors and generators load in processes that never loaded a plugin
+    // (batch workers, forked tasks), so the NodeNext `.js` -> `.ts` resolvers the
+    // plugin loader installs are not there yet. Both are idempotent.
+    ensureCjsResolverPatched();
+    if (preferNodeStripTypes) {
+        ensureNodeNextEsmResolverRegistered();
+    }
     if (!preferNodeStripTypes) {
         if (!resolvedTsConfigPath) {
             throw new Error(`${logger_1.NX_PREFIX} loadTsFile could not find a workspace tsconfig while loading ${filePath} on the swc/ts-node path. Pass an explicit tsConfigPath or add a tsconfig.base.json/tsconfig.json at the workspace root.`);
@@ -858,9 +866,10 @@ function loadTsFile(filePath, tsConfigPath) {
             cleanup();
         }
     }
-    // Native strip path: no registration up front. pnpm/npm/yarn workspaces
-    // resolve aliases without tsconfig-paths. On failure, lazy-register what
-    // the specific error code indicates is needed and retry:
+    // Native strip path: no tsconfig-paths or transpiler registration up
+    // front. pnpm/npm/yarn workspaces resolve aliases without tsconfig-paths.
+    // On failure, lazy-register what the specific error code indicates is
+    // needed and retry:
     //   - MODULE_NOT_FOUND -> first try tsconfig-paths (alias resolution).
     //     If that still fails (e.g. extensionless `import './foo'` when
     //     `foo.ts` is adjacent - Node's resolver doesn't add `.ts`), escalate
@@ -1208,7 +1217,7 @@ function resolvePathsBaseUrl(tsconfigPath) {
         const absolute = (0, path_1.resolve)(queue.shift());
         const dir = (0, path_1.dirname)(absolute);
         try {
-            const raw = JSON.parse((0, fs_1.readFileSync)(absolute, 'utf-8'));
+            const raw = (0, fileutils_1.readJsonFile)(absolute);
             chain.push({ dir, raw });
             const exts = raw.extends
                 ? Array.isArray(raw.extends)

package/dist/src/plugins/package-json/create-nodes.d.ts

@@ -3,7 +3,7 @@ import type { ProjectConfiguration } from '../../config/workspace-json-project-j
 import { PackageJson } from '../../utils/package-json';
 import { PackageManagerCommands } from '../../utils/package-manager';
 import { CreateNodes } from '../../project-graph/plugins';
-import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
+import type { PackageJsonConfigurationCache } from '../../../plugins/package-json';
 export declare const createNodes: CreateNodes;
 export declare function buildPackageJsonPatterns(workspaceRoot: string, readJson: (path: string) => any): PackageJsonPatterns;
 type PackageJsonPatterns = {
@@ -13,7 +13,7 @@ type PackageJsonPatterns = {
     negativeLookup: Record<string, boolean>;
 };
 export declare function buildPackageJsonWorkspacesMatcher(patterns: PackageJsonPatterns): (p: any) => boolean;
-export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache, isInPackageManagerWorkspaces: boolean, packageManagerCommand: PackageManagerCommands): {
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache | undefined, isInPackageManagerWorkspaces: boolean, packageManagerCommand: PackageManagerCommands, nxJson?: NxJsonConfiguration): {
     projects: {
         [x: string]: ProjectConfiguration;
     };

package/dist/src/plugins/package-json/create-nodes.js

@@ -22,7 +22,6 @@ const versions_1 = require("../../utils/versions");
 const plugins_1 = require("../../project-graph/plugins");
 const path_2 = require("path");
 const file_hasher_1 = require("../../hasher/file-hasher");
-const package_json_2 = require("../../../plugins/package-json");
 const globPatterns = (0, globs_1.combineGlobPatterns)('package.json', '**/package.json', 'project.json', '**/project.json');
 exports.createNodes = [
     globPatterns,
@@ -38,7 +37,6 @@ exports.createNodes = [
         const isNextToProjectJson = (packageJsonPath) => {
             return projectJsonRoots.has((0, node_path_1.dirname)(packageJsonPath));
         };
-        const cache = (0, package_json_2.readPackageJsonConfigurationCache)();
         const packageManagerCommand = (0, package_manager_1.getPackageManagerCommand)((0, package_manager_1.detectPackageManager)(context.workspaceRoot), context.workspaceRoot);
         return (0, plugins_1.createNodesFromFiles)((packageJsonPath, options, context) => {
             const isInPackageManagerWorkspaces = isInPackageJsonWorkspaces(packageJsonPath);
@@ -47,7 +45,7 @@ exports.createNodes = [
                 // Skip if package.json is not part of the package.json workspaces and not next to a project.json.
                 return null;
             }
-            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand);
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, undefined, isInPackageManagerWorkspaces, packageManagerCommand, context.nxJsonConfiguration);
         }, packageJsons, _, context);
     },
 ];
@@ -115,16 +113,18 @@ function buildPackageJsonWorkspacesMatcher(patterns) {
         !patterns.negativeLookup[p] &&
         negative.every((m) => m.match(p));
 }
-function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand) {
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces, packageManagerCommand, nxJson) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
     const projectRoot = (0, node_path_1.dirname)(pkgJsonPath);
-    const hash = (0, file_hasher_1.hashObject)({
-        ...json,
-        root: projectRoot,
-        isInPackageManagerWorkspaces,
-        nxVersion: versions_1.nxVersion,
-    });
-    const cached = cache.get(hash);
+    const hash = cache
+        ? (0, file_hasher_1.hashObject)({
+            ...json,
+            root: projectRoot,
+            isInPackageManagerWorkspaces,
+            nxVersion: versions_1.nxVersion,
+        })
+        : undefined;
+    const cached = cache?.get(hash);
     if (cached) {
         return {
             projects: {
@@ -132,8 +132,8 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackag
             },
         };
     }
-    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces, packageManagerCommand);
-    cache.set(hash, project);
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, nxJson ?? (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces, packageManagerCommand);
+    cache?.set(hash, project);
     return {
         projects: {
             [project.root]: project,

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[]>;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTouchedProjectLocators = runTouchedProjectLocators;
+exports.getProjectGlobPatterns = getProjectGlobPatterns;
+const native_1 = require("../../native");
+const get_plugins_1 = require("../plugins/get-plugins");
+const workspace_root_1 = require("../../utils/workspace-root");
+const file_utils_1 = require("../file-utils");
+const touched_projects_1 = require("../../plugins/js/project-graph/affected/touched-projects");
+const transform_objects_1 = require("../../native/transform-objects");
+/** Runs every locator and returns what each one marked, duplicates included. */
+async function runTouchedProjectLocators(graph, touchedFiles, nxJson, packageJson, projectDeletionAffectsAllProjects = true) {
+    return (0, native_1.locateTouchedProjects)((0, transform_objects_1.transformProjectGraphForLocators)(graph), nxJson, touchedFiles.map((f) => f.file), {
+        // Only a deletion reaches projects_from_project_glob_changes, and
+        // resolving the patterns can fall back to starting plugin workers.
+        projectGlobPatterns: touchedFiles.some((f) => (0, file_utils_1.isDeletedFile)(f.file))
+            ? await getProjectGlobPatterns(nxJson)
+            : [],
+        projectDeletionAffectsAllProjects,
+        workspaceRoot: workspace_root_1.workspaceRoot,
+    }, 
+    // Takes only paths, so the closure carries the FileChange objects: their
+    // lazy getChanges() cannot cross the native boundary.
+    [
+        async () => (0, touched_projects_1.getTouchedProjects)(touchedFiles, graph.nodes, nxJson, packageJson, graph, projectDeletionAffectsAllProjects),
+    ]);
+}
+/** Resolved here because the native side takes the patterns, not the plugins. */
+async function getProjectGlobPatterns(nxJson) {
+    if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
+        return [
+            '**/package.json',
+            '**/project.json',
+            'project.json',
+            'package.json',
+        ];
+    }
+    const capabilities = await (0, get_plugins_1.capabilitiesOfConfiguredPlugins)(nxJson, workspace_root_1.workspaceRoot);
+    return capabilities
+        .map((capability) => capability.createNodesPattern)
+        .filter((pattern) => !!pattern);
+}