@depup/nx 23.1.2-depup.1 → 23.2.0-depup.0

package/dist/src/daemon/server/handle-client-env.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._setEnvForwardTimeoutMs = _setEnvForwardTimeoutMs;
+exports.handleClientEnv = handleClientEnv;
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
+const daemon_environment_1 = require("../client/daemon-environment");
+const logger_1 = require("../logger");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+// Bounds the wait for worker acknowledgements so a wedged worker cannot hold
+// every env-carrying client message for the 10-minute plugin-hook timeout. A
+// healthy worker applies the env synchronously and acks in milliseconds.
+let envForwardTimeoutMs = 10_000;
+// Test seam: the production timeout would stall the suite.
+function _setEnvForwardTimeoutMs(ms) {
+    envForwardTimeoutMs = ms;
+}
+let inFlightApply;
+/**
+ * Applies an env-carrying client message to the daemon. Must be awaited
+ * before dispatching the message's handler: plugin workers key their disk
+ * caches on their own process env, so a graph request must not reach a worker
+ * whose env still reflects the previous client.
+ */
+async function handleClientEnv(env) {
+    // A client whose env matches one an in-flight apply already wrote to
+    // process.env sees zero changed keys, yet the graph cache is only discarded
+    // once that apply's forwarding completes. Wait for it so such a client
+    // cannot be served the graph computed under the previous env.
+    while (inFlightApply) {
+        await inFlightApply;
+    }
+    const changedEnvKeys = (0, daemon_environment_1.applyDaemonEnvFromClient)(env);
+    if (changedEnvKeys.length === 0) {
+        return;
+    }
+    logger_1.serverLogger.log(`Graph recompute necessary due to env variable refresh. Changed keys: ${changedEnvKeys.join(', ')}`);
+    const apply = applyEnvChange(env);
+    inFlightApply = apply;
+    try {
+        await apply;
+    }
+    finally {
+        if (inFlightApply === apply) {
+            inFlightApply = undefined;
+        }
+    }
+}
+async function applyEnvChange(env) {
+    await forwardEnvToPluginWorkers(env);
+    // Discarding the cached graph makes the next request recompute under the
+    // new env, and chains any in-flight compute (started under the old env) to
+    // that successor.
+    (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
+}
+// Covers committed workers and an in-flight load, whose workers forked under
+// the previous env before this apply and would otherwise keep it for good. A
+// load started after this needs no forwarding: its workers fork with the
+// daemon's already-updated process.env. Each forward settles rather than
+// rejects so one dead worker (or a failed load) cannot fail every env-carrying
+// client message. Timing out is safe: each worker socket delivers the already
+// sent env update before any later graph message, and the plugin cache write
+// guard drops a pass the update lands in the middle of.
+async function forwardEnvToPluginWorkers(env) {
+    let timer;
+    const timedOut = await Promise.race([
+        forwardEnvToPluginWorkersUnbounded(env).then(() => false),
+        new Promise((resolve) => {
+            timer = setTimeout(() => resolve(true), envForwardTimeoutMs);
+            timer.unref();
+        }),
+    ]).finally(() => clearTimeout(timer));
+    if (timedOut) {
+        logger_1.serverLogger.log(`Timed out forwarding the new env to plugin workers after ${envForwardTimeoutMs}ms; continuing without their acknowledgement.`);
+    }
+}
+async function forwardEnvToPluginWorkersUnbounded(env) {
+    const pluginsPromise = (0, get_plugins_1.getPluginsIfLoadedOrLoading)();
+    if (!pluginsPromise) {
+        return;
+    }
+    let plugins;
+    try {
+        plugins = await pluginsPromise;
+    }
+    catch {
+        // The load failed, so there are no workers to forward to.
+        return;
+    }
+    await Promise.all(plugins.map((plugin) => plugin.setWorkerEnv?.(env)?.catch((e) => {
+        logger_1.serverLogger.log(`Failed to forward env to plugin worker "${plugin.name}": ${e.message}`);
+    })));
+}

package/dist/src/daemon/server/handle-outputs-changes.d.ts

@@ -0,0 +1,10 @@
+import type { FileWatcherCallback } from './watcher';
+/**
+ * The error a native outputs watcher failure delivered, if one has. Such an
+ * error is terminal (the native watch loop exits after delivering it), so the
+ * gitignored dotenv edits only that watcher reports stop arriving and a warm
+ * graph would go stale silently. The server fails requests closed on it, like
+ * a workspace watcher error.
+ */
+export declare function getOutputsWatcherTerminalError(): Error | undefined;
+export declare const handleOutputsChanges: FileWatcherCallback;

package/dist/src/daemon/server/handle-outputs-changes.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOutputsChanges = void 0;
+exports.getOutputsWatcherTerminalError = getOutputsWatcherTerminalError;
+const logger_1 = require("../logger");
+const dotenv_graph_changes_1 = require("./dotenv-graph-changes");
+const outputs_tracking_1 = require("./outputs-tracking");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+let outputsWatcherError;
+let outputsWatcherTerminalError;
+/**
+ * The error a native outputs watcher failure delivered, if one has. Such an
+ * error is terminal (the native watch loop exits after delivering it), so the
+ * gitignored dotenv edits only that watcher reports stop arriving and a warm
+ * graph would go stale silently. The server fails requests closed on it, like
+ * a workspace watcher error.
+ */
+function getOutputsWatcherTerminalError() {
+    return outputsWatcherTerminalError;
+}
+const handleOutputsChanges = async (err, changeEvents) => {
+    try {
+        if (err || !changeEvents || !changeEvents.length) {
+            let error = typeof err === 'string' ? new Error(err) : err;
+            logger_1.serverLogger.watcherLog('Unexpected outputs watcher error', error.message);
+            console.error(error);
+            outputsWatcherError = error;
+            (0, outputs_tracking_1.disableOutputsTracking)();
+            if (err) {
+                // A native error is terminal: the watch loop has exited, so the
+                // gitignored dotenv edits only this watcher reports stop arriving and
+                // the graph invalidation below can never run again. Fail requests
+                // closed like a workspace watcher error rather than serving a graph
+                // that silently goes stale. The original error is preserved so an
+                // inotify_add_watch failure still makes the client disable the daemon
+                // and rebuild without it.
+                outputsWatcherTerminalError = error;
+            }
+            return;
+        }
+        // A dotenv change that a task chain loads must refresh the graph so
+        // createNodes re-resolves config reading process.env. This runs above the
+        // outputsWatcherError guard: the two concerns are independent, and a
+        // disabled outputs tracker must not leave the graph stale on a dotenv edit.
+        // A change to a file the workspace watcher tracks already schedules a
+        // recomputation that reads the new content; invalidating for it here too
+        // would discard that recomputation at commit and force a second one. It is
+        // queued instead of dropped: the two watchers deliver independently, so a
+        // computation already in flight may have read the file before the edit,
+        // and only the pre-serve replay can prove that. The committed file map
+        // approximates what the watcher tracks: a file it does not know is either
+        // gitignored (never reaches the workspace watcher, so it needs the
+        // invalidation) or created since the last recompute (the watcher handles
+        // it; the extra invalidation is fail-safe). Its own try/catch so a fault
+        // here cannot trip the outputs-tracking kill switch below, which belongs
+        // to an unrelated subsystem, and it fails safe by invalidating: a stale
+        // graph on a dotenv edit is the bug this prevents.
+        try {
+            const { invalidating, unclassified } = (0, dotenv_graph_changes_1.classifyDotEnvChanges)(changeEvents, project_graph_incremental_recomputation_1.currentProjectGraph);
+            const generation = (0, project_graph_incremental_recomputation_1.getRecomputationGeneration)();
+            (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(unclassified.map((event) => event.path), generation);
+            const knownInvalidating = invalidating.filter((path) => (0, project_graph_incremental_recomputation_1.isKnownWorkspaceFile)(path));
+            (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(knownInvalidating, generation);
+            if (knownInvalidating.length < invalidating.length) {
+                (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
+            }
+        }
+        catch (e) {
+            logger_1.serverLogger.watcherLog('Failed to evaluate dotenv changes for graph invalidation; invalidating the graph cache to be safe', e instanceof Error ? e.message : String(e));
+            console.error(e);
+            (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
+        }
+        if (outputsWatcherError) {
+            return;
+        }
+        logger_1.serverLogger.watcherLog('Processing file changes in outputs');
+        (0, outputs_tracking_1.processFileChangesInOutputs)(changeEvents);
+    }
+    catch (err) {
+        logger_1.serverLogger.watcherLog(`Unexpected outputs watcher error`, err.message);
+        console.error(err);
+        outputsWatcherError = err;
+        (0, outputs_tracking_1.disableOutputsTracking)();
+    }
+};
+exports.handleOutputsChanges = handleOutputsChanges;

package/dist/src/daemon/server/project-graph-incremental-recomputation.d.ts

@@ -22,5 +22,26 @@ export declare let currentSourceMaps: ConfigurationSourceMaps | undefined;
 export declare function getCachedSerializedProjectGraphPromise(socket?: Socket): Promise<SerializedProjectGraph>;
 export declare function scheduleProjectGraphRecomputation(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
 export declare function registerProjectGraphRecomputationListener(listener: (projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, error: Error | null) => void): void;
+/**
+ * Discards the cached graph when a graph input outside the file watcher's view
+ * (e.g. the daemon env) changes. Clearing the cached promise makes the next
+ * request trigger a fresh computation; the generation bump marks any in-flight
+ * compute stale so it chains to that successor instead of committing, because
+ * a compute passing its chainToLatest checks would serve a graph built under
+ * the old input to whoever already awaits it.
+ */
 export declare function invalidateGraphCache(): void;
+/**
+ * The current recomputation generation, stamped on queued dotenv events so
+ * the pre-serve drain can prove whether a computation started before an
+ * event arrived.
+ */
+export declare function getRecomputationGeneration(): number;
+/**
+ * Whether the ignore-filtered workspace file map knows `path`. The workspace
+ * watcher applies the same ignore rules, so a change to a known file also
+ * reaches scheduleProjectGraphRecomputation; an unknown file is either
+ * ignored, or created since the last recompute committed.
+ */
+export declare function isKnownWorkspaceFile(path: string): boolean;
 export {};

package/dist/src/daemon/server/project-graph-incremental-recomputation.js

@@ -5,6 +5,8 @@ exports.getCachedSerializedProjectGraphPromise = getCachedSerializedProjectGraph
 exports.scheduleProjectGraphRecomputation = scheduleProjectGraphRecomputation;
 exports.registerProjectGraphRecomputationListener = registerProjectGraphRecomputationListener;
 exports.invalidateGraphCache = invalidateGraphCache;
+exports.getRecomputationGeneration = getRecomputationGeneration;
+exports.isKnownWorkspaceFile = isKnownWorkspaceFile;
 const perf_hooks_1 = require("perf_hooks");
 const nx_json_1 = require("../../config/nx-json");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -19,6 +21,7 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const workspace_root_1 = require("../../utils/workspace-root");
 const progress_topics_1 = require("../../utils/progress-topics");
 const client_socket_context_1 = require("./client-socket-context");
+const dotenv_graph_changes_1 = require("./dotenv-graph-changes");
 const file_change_events_1 = require("./file-watching/file-change-events");
 const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
 const project_graph_listener_sockets_1 = require("./project-graph-listener-sockets");
@@ -34,6 +37,18 @@ let storedWorkspaceConfigHash;
 let knownExternalNodes = {};
 let fileChangeCounter = 0;
 let recomputationGeneration = 0;
+// The graph the settled cached promise serves, with the generation its
+// computation claimed. Set only when a computation's own success becomes the
+// cached result; any newer kickoff or invalidation clears it, so non-null
+// means the cached promise is settled and this is exactly what it serves. The
+// warm-reuse dotenv check classifies against this, never against
+// `currentProjectGraph`: a slow stale computation overwrites that after the
+// winner settles and only then chains away. The candidate is written by the
+// computation itself (which knows its generation) and promoted by
+// kickOffRecompute after the outer plugin-hash and cached-pointer identity
+// checks, which can still reject the result.
+let servedGraphState = null;
+let servedGraphCandidate = null;
 // True after the first successful persistProjectGraphToDisk call. Until
 // that happens, "project-graph.json missing on disk" is the expected
 // state (we just haven't written it yet) and must not trigger a reset.
@@ -47,6 +62,9 @@ let cacheHasBeenPersisted = false;
  * (see spread.test.ts "middle plugin" flake).
  */
 function kickOffRecompute() {
+    // The cached pointer is about to hold an unsettled promise, so whatever the
+    // previous state described is no longer what the cache serves.
+    servedGraphState = null;
     let myPromise;
     myPromise = (async () => {
         // Must resolve, never reject: kickOffRecompute() runs fire-and-forget, so
@@ -69,6 +87,12 @@ function kickOffRecompute() {
                 return chainToSuccessor(myPromise);
             if (cachedSerializedProjectGraphPromise === myPromise &&
                 result.projectGraph) {
+                // The graph identity ties the candidate's generation to exactly this
+                // result; a chained result never matches (its computation's kickoff
+                // replaced the cached pointer, failing the identity check above).
+                if (servedGraphCandidate?.graph === result.projectGraph) {
+                    servedGraphState = servedGraphCandidate;
+                }
                 notifyProjectGraphRecomputationListeners(result.projectGraph, result.sourceMaps, result.error);
                 persistProjectGraphToDisk(result);
             }
@@ -121,6 +145,28 @@ async function getCachedSerializedProjectGraphPromise(socket) {
         // stale graph. Placed right before the read so no microtask gap
         // separates them.
         await new Promise(setImmediate);
+        // The queue can hold evidence against the settled cached graph itself: a
+        // tracked dotenv edit only the outputs watcher has delivered yet queues
+        // without invalidating, and the workspace watcher's recomputation may lag
+        // this request. Classified against the exact graph the cache serves; an
+        // in-flight computation needs no check here because its own pre-serve
+        // replay consumes the queue. Content hashes are dropped before the
+        // successor can read, as in the error retry: one recorded when the edit
+        // was classified could suppress a revert landing mid-read. Fails toward
+        // recomputing, since a stale graph on a dotenv edit is the bug this
+        // prevents.
+        try {
+            if (servedGraphState &&
+                (0, dotenv_graph_changes_1.hasRelevantPendingDotEnvEvidence)(servedGraphState.graph, servedGraphState.generation)) {
+                (0, dotenv_graph_changes_1.clearDotEnvFileHashes)();
+                invalidateGraphCache();
+            }
+        }
+        catch (e) {
+            logger_1.serverLogger.log(`Failed to check pending dotenv changes against the cached graph; recomputing to be safe: ${e instanceof Error ? e.message : e}`);
+            (0, dotenv_graph_changes_1.clearDotEnvFileHashes)();
+            invalidateGraphCache();
+        }
         // If no compute exists or events are still in collected*, kick one off.
         // Otherwise reuse whatever is already in flight or cached.
         const needsRecompute = !cachedSerializedProjectGraphPromise ||
@@ -266,13 +312,60 @@ async function processCollectedUpdatedAndDeletedFiles({ projects, externalNodes,
         throw e;
     }
 }
+/**
+ * Discards the cached graph when a graph input outside the file watcher's view
+ * (e.g. the daemon env) changes. Clearing the cached promise makes the next
+ * request trigger a fresh computation; the generation bump marks any in-flight
+ * compute stale so it chains to that successor instead of committing, because
+ * a compute passing its chainToLatest checks would serve a graph built under
+ * the old input to whoever already awaits it.
+ */
 function invalidateGraphCache() {
-    // Clear the cached promise so the next request triggers a fresh computation.
     // We intentionally do NOT call getCachedSerializedProjectGraphPromise() here
     // because assigning its return Promise to the module-level variable causes a
     // deadlock: the async function resumes, sees the variable is non-null (pointing
     // at its own Promise), takes the "reuse" branch, and awaits itself forever.
     cachedSerializedProjectGraphPromise = null;
+    ++recomputationGeneration;
+    servedGraphState = null;
+}
+/**
+ * The current recomputation generation, stamped on queued dotenv events so
+ * the pre-serve drain can prove whether a computation started before an
+ * event arrived.
+ */
+function getRecomputationGeneration() {
+    return recomputationGeneration;
+}
+// isKnownWorkspaceFile's membership set, derived lazily from the map object it
+// was built from; every `fileMapWithFiles` write clears it, so a replaced map
+// generation is not retained through the memo.
+let knownWorkspaceFiles;
+let knownWorkspaceFilesSource;
+/**
+ * Whether the ignore-filtered workspace file map knows `path`. The workspace
+ * watcher applies the same ignore rules, so a change to a known file also
+ * reaches scheduleProjectGraphRecomputation; an unknown file is either
+ * ignored, or created since the last recompute committed.
+ */
+function isKnownWorkspaceFile(path) {
+    if (!exports.fileMapWithFiles) {
+        return false;
+    }
+    if (knownWorkspaceFilesSource !== exports.fileMapWithFiles) {
+        const { projectFileMap, nonProjectFiles } = exports.fileMapWithFiles.fileMap;
+        knownWorkspaceFiles = new Set();
+        for (const { file } of nonProjectFiles) {
+            knownWorkspaceFiles.add(file);
+        }
+        for (const files of Object.values(projectFileMap)) {
+            for (const { file } of files) {
+                knownWorkspaceFiles.add(file);
+            }
+        }
+        knownWorkspaceFilesSource = exports.fileMapWithFiles;
+    }
+    return knownWorkspaceFiles.has(path);
 }
 async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
     const plugins = [
@@ -280,6 +373,14 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         ...separatedPlugins.defaultPlugins,
     ];
     const myGeneration = ++recomputationGeneration;
+    // A hash recorded before this claim can describe bytes this computation
+    // never reads (a callback classified between a forced invalidation and this
+    // claim records one no handler-side clear has seen), and retained it could
+    // suppress a coalesced revert landing mid-read. Bounding every hash to the
+    // window since the last claim closes that for any successor, however it was
+    // forced. A callback landing after this claim re-records and re-queues, and
+    // its stamp then marks this computation stale at the drain.
+    (0, dotenv_graph_changes_1.clearDotEnvFileHashes)();
     // A newer kickOffRecompute has already replaced
     // cachedSerializedProjectGraphPromise. Returning it lets the async
     // unwrap chain our caller onto the newer compute's result; pass
@@ -341,6 +442,8 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         // chainToLatest above without touching `fileMapWithFiles`, so they
         // can't clobber a newer compute's write.
         exports.fileMapWithFiles = fileMapUpdate.fileMap;
+        knownWorkspaceFiles = undefined;
+        knownWorkspaceFilesSource = undefined;
         storedWorkspaceConfigHash = fileMapUpdate.configHash;
         if (fileMapUpdate.knownExternalNodes) {
             knownExternalNodes = fileMapUpdate.knownExternalNodes;
@@ -373,13 +476,59 @@ async function processFilesAndCreateAndSerializeProjectGraph(separatedPlugins) {
         const aggregate = g.error && (0, error_types_1.isAggregateProjectGraphError)(g.error) && g.error.errors?.length
             ? g.error
             : null;
-        if (g.error && !aggregate)
-            return errorResult(g.error);
+        // An error result is never cached, notified, or persisted, so a queued
+        // dotenv edit that may already have fixed the failing input earns one
+        // retry instead of surfacing the error. The peek consumes nothing (a
+        // successful successor's drain classifies the entries against a real
+        // graph, which these branches may lack: `g.projectGraph` can be null
+        // here) and a persistent error retries once, because the successor
+        // claims a generation above every recorded stamp. Content hashes are
+        // dropped, though: one recorded during this failed computation could
+        // suppress a callback landing while the successor reads. The catch at
+        // the end of this function stays excluded: a throw there can predate
+        // projectConfigurationsResult and the plugin hooks' balancing, and the
+        // next request recomputes at a fresh generation anyway.
+        const retryForPendingDotEnv = () => {
+            if (!(0, dotenv_graph_changes_1.hasPendingDotEnvEvidence)(myGeneration))
+                return null;
+            (0, dotenv_graph_changes_1.clearDotEnvFileHashes)();
+            invalidateGraphCache();
+            return chainToLatest(false);
+        };
+        if (g.error && !aggregate) {
+            return retryForPendingDotEnv() ?? errorResult(g.error);
+        }
         if (aggregate)
             errors.push(...aggregate.errors);
-        if (errors.length === 0)
-            return g;
-        return errorResult(new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps));
+        if (errors.length > 0) {
+            return (retryForPendingDotEnv() ??
+                errorResult(new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps)));
+        }
+        // Replay the dotenv events no committed root could classify on arrival
+        // against the graph about to be served. Runs after the last staleness
+        // gate so a stale compute leaves the queue for its successor, and only
+        // on the success path: an error result is never notified or persisted.
+        // Queue evidence is decisive here even for files the workspace watcher
+        // tracks: the two watchers deliver independently, so tracking alone does
+        // not prove that watcher's recomputation was already scheduled.
+        let staleDotEnv;
+        try {
+            const pending = (0, dotenv_graph_changes_1.drainPendingDotEnvEvents)(g.projectGraph, myGeneration);
+            staleDotEnv = pending.overflowed || pending.invalidating.length > 0;
+        }
+        catch (e) {
+            logger_1.serverLogger.log(`Failed to re-check pending dotenv changes; recomputing to be safe: ${e instanceof Error ? e.message : e}`);
+            staleDotEnv = true;
+        }
+        if (staleDotEnv) {
+            // This graph read the file before the queued edit landed. The bump plus
+            // chain hands every awaiting caller the successor's result and keeps
+            // this one from being notified or persisted.
+            invalidateGraphCache();
+            return chainToLatest(false);
+        }
+        servedGraphCandidate = { graph: g.projectGraph, generation: myGeneration };
+        return g;
     }
     catch (err) {
         return errorResult(err);
@@ -464,7 +613,11 @@ async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
 }
 async function resetInternalState() {
     cachedSerializedProjectGraphPromise = undefined;
+    servedGraphState = null;
+    servedGraphCandidate = null;
     exports.fileMapWithFiles = undefined;
+    knownWorkspaceFiles = undefined;
+    knownWorkspaceFilesSource = undefined;
     exports.currentProjectFileMapCache = undefined;
     exports.currentProjectGraph = undefined;
     exports.currentSourceMaps = undefined;