fix(core): skip writing deps cache if already up-to-date (#34582)

## Current Behavior
Frequent write cache calls during tasks hashing results in delays

## Expected Behavior
Cache is validated but only written when changed

## AI Summary
This pull request introduces an optimization to the project graph cache
writing logic, reducing unnecessary disk writes when serving repeated
requests with unchanged graphs. The main change is the addition of a
mechanism to track the cache file's modification time and only write to
disk if the file has been externally modified or not written yet by the
current process.

Optimizations to cache writing:

* Added `writeCacheIfStale` function in `nx-deps-cache.ts` to prevent
redundant cache writes by checking the cache file's modification time
before writing. This function is now used in the daemon's graph
recomputation logic, replacing the previous unconditional write.
[[1]](diffhunk://#diff-82bd1a5a7b7320ffc3233470f191782c054bf69a696dc16001d2c4b1d0b04963R285-R312)
[[2]](diffhunk://#diff-d5bf3c66e62cac1884a071bf07fd1991320a3e62b07bfc03af3b9557b714c892L17-R17)
[[3]](diffhunk://#diff-d5bf3c66e62cac1884a071bf07fd1991320a3e62b07bfc03af3b9557b714c892L136-R149)
* Introduced `lastWrittenCacheMtimeMs` variable to track the last
successful write's modification time, updated after each cache write.
[[1]](diffhunk://#diff-82bd1a5a7b7320ffc3233470f191782c054bf69a696dc16001d2c4b1d0b04963R202-R208)
[[2]](diffhunk://#diff-82bd1a5a7b7320ffc3233470f191782c054bf69a696dc16001d2c4b1d0b04963R256-R261)

Codebase updates:

* Updated imports in `nx-deps-cache.ts` to include `statSync` for file
modification time checks.

## Related Issue(s)
<!-- Please link the issue being fixed so it gets closed when this is
merged. -->

Fixes #

Author: AgentEnder

packages/nx/src/daemon/server/project-graph-incremental-recomputation.ts

@@ -15,6 +15,7 @@ import {
   nxProjectGraph,
   readFileMapCache,
   writeCache,
+  writeCacheIfStale,
 } from '../../project-graph/nx-deps-cache';
 import {
   retrieveProjectConfigurations,
@@ -98,6 +99,7 @@ export async function getCachedSerializedProjectGraphPromise(): Promise<Serializ
     waitPeriod = 100;
     await resetInternalStateIfNxDepsMissing();
     const plugins = await getPlugins();
+    const previousPromise = cachedSerializedProjectGraphPromise;
     if (collectedUpdatedFiles.size == 0 && collectedDeletedFiles.size == 0) {
       if (!cachedSerializedProjectGraphPromise) {
         cachedSerializedProjectGraphPromise =
@@ -117,6 +119,8 @@ export async function getCachedSerializedProjectGraphPromise(): Promise<Serializ
       cachedSerializedProjectGraphPromise =
         processFilesAndCreateAndSerializeProjectGraph(plugins);
     }
+    const graphWasRecomputed =
+      cachedSerializedProjectGraphPromise !== previousPromise;
     const result = await cachedSerializedProjectGraphPromise;
 
     if (wasScheduled) {
@@ -133,16 +137,22 @@ export async function getCachedSerializedProjectGraphPromise(): Promise<Serializ
         : [result.error]
       : [];
 
-    // Always write the daemon's current graph to disk to ensure disk cache
-    // stays in sync with the daemon's in-memory cache. This prevents issues
-    // where a non-daemon process writes a stale/errored cache that never
-    // gets overwritten by the daemon's valid graph.
+    // Write the daemon's current graph to disk to ensure disk cache stays
+    // in sync with the daemon's in-memory cache. This prevents issues where
+    // a non-daemon process writes a stale/errored cache that never gets
+    // overwritten by the daemon's valid graph.
+    //
+    // When the graph was just recomputed, always write so the new graph is
+    // persisted. When serving the same graph from memory, use
+    // writeCacheIfStale to skip the write unless an external process has
+    // modified the file since this process last wrote it.
     if (
       result.projectGraph &&
       result.projectFileMapCache &&
       result.sourceMaps
     ) {
-      writeCache(
+      const writeFn = graphWasRecomputed ? writeCache : writeCacheIfStale;
+      writeFn(
         result.projectFileMapCache,
         result.projectGraph,
         result.sourceMaps,

packages/nx/src/project-graph/nx-deps-cache.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, renameSync } from 'node:fs';
+import { existsSync, mkdirSync, renameSync, statSync } from 'node:fs';
 import { join } from 'path';
 import { performance } from 'perf_hooks';
 import { NxJsonConfiguration } from '../config/nx-json';
@@ -199,6 +199,13 @@ export function createProjectFileMapCache(
   return newValue;
 }
 
+/**
+ * Tracks the mtime of the project graph cache file after the last successful
+ * writeCache() call. Used by writeCacheIfStale() to skip redundant writes
+ * when no external process has modified the cache file since the last write.
+ */
+let lastWrittenCacheMtimeMs: number | undefined;
+
 export function writeCache(
   cache: FileMapCache,
   projectGraph: ProjectGraph,
@@ -246,6 +253,12 @@ export function writeCache(
         );
       }
 
+      try {
+        lastWrittenCacheMtimeMs = statSync(nxProjectGraph).mtimeMs;
+      } catch {
+        lastWrittenCacheMtimeMs = undefined;
+      }
+
       done = true;
     } catch (err: any) {
       if (err instanceof Error) {
@@ -269,6 +282,34 @@ export function writeCache(
   performance.measure('write cache', 'write cache:start', 'write cache:end');
 }
 
+/**
+ * Writes the cache only if the on-disk cache file has been modified since
+ * this process last wrote it (i.e. an external process overwrote it), or
+ * if this process has never written the cache.
+ *
+ * Use this instead of writeCache() on hot paths where the same graph may
+ * be served multiple times without changing (e.g. the daemon responding
+ * to repeated client requests).
+ */
+export function writeCacheIfStale(
+  cache: FileMapCache,
+  projectGraph: ProjectGraph,
+  sourceMaps: ConfigurationSourceMaps,
+  errors: ProjectGraphErrorTypes[]
+): void {
+  if (lastWrittenCacheMtimeMs !== undefined) {
+    try {
+      const currentMtimeMs = statSync(nxProjectGraph).mtimeMs;
+      if (currentMtimeMs === lastWrittenCacheMtimeMs) {
+        return;
+      }
+    } catch {
+      // File doesn't exist or can't be stat'd — proceed with write
+    }
+  }
+  writeCache(cache, projectGraph, sourceMaps, errors);
+}
+
 export function shouldRecomputeWholeGraph(
   cache: FileMapCache,
   packageJsonDeps: Record<string, string>,