nx 23.3.0-beta.0 → 23.3.0-beta.2

package/dist/src/daemon/client/client.d.ts

@@ -3,10 +3,12 @@ import { FileData, ProjectGraph } from '../../config/project-graph';
 import { Task, TaskGraph } from '../../config/task-graph';
 import { Hash } from '../../hasher/task-hasher';
 import { NxWorkspaceFiles, TaskRun, TaskTarget } from '../../native';
-import { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import { PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/plugins/task-results-stub';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
 import type { FlushSyncGeneratorChangesResult, SyncGeneratorRunResult } from '../../utils/sync-generators';
 import { type ConfigureAiAgentsStatusResponse } from '../message-types/configure-ai-agents';
+import type { NxPluginCapabilities } from '../../project-graph/plugins/nx-plugin-capabilities';
 import { type NxConsoleStatusResponse, type SetNxConsolePreferenceAndInstallResponse } from '../message-types/nx-console';
 /** A refused connect: the errno, and the path it was made against. */
 type ConnectRefusal = {
@@ -57,6 +59,7 @@ export declare class DaemonClient {
     }>;
     getAllFileData(): Promise<FileData[]>;
     hashTasks(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTasksUpfront(runnerOptions: any, tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd: string, collectInputs?: boolean): Promise<Record<string, Hash>>;
     registerFileWatcher(config: {
         watchProjects: string[] | 'all';
         includeGlobalWorkspaceFiles?: boolean;
@@ -98,9 +101,10 @@ export declare class DaemonClient {
         globalGenerators: string[];
         taskGenerators: string[];
     }>;
+    getPluginCapabilities(): Promise<NxPluginCapabilities[]>;
     updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
     runPreTasksExecution(context: PreTasksExecutionContext): Promise<NodeJS.ProcessEnv[]>;
-    runPostTasksExecution(context: PostTasksExecutionContext): Promise<void>;
+    runPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<void>;
     getNxConsoleStatus(): Promise<NxConsoleStatusResponse>;
     setNxConsolePreferenceAndInstall(preference: boolean): Promise<SetNxConsolePreferenceAndInstallResponse>;
     getConfigureAiAgentsStatus(): Promise<ConfigureAiAgentsStatusResponse>;

package/dist/src/daemon/client/client.js

@@ -11,6 +11,7 @@ const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const configuration_1 = require("../../config/configuration");
 const nx_json_1 = require("../../config/nx-json");
+const prune_task_graph_1 = require("../../tasks-runner/prune-task-graph");
 const native_1 = require("../../native");
 const error_types_1 = require("../../project-graph/error-types");
 const typescript_1 = require("../../plugins/js/utils/typescript");
@@ -34,6 +35,7 @@ const get_context_file_data_1 = require("../message-types/get-context-file-data"
 const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
 const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-files");
 const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const get_plugin_capabilities_1 = require("../message-types/get-plugin-capabilities");
 const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
 const hash_glob_1 = require("../message-types/hash-glob");
 const nx_console_1 = require("../message-types/nx-console");
@@ -74,6 +76,14 @@ exports.WatcherFailedError = WatcherFailedError;
  * re-dialing once this many land back to back without a message in between.
  */
 const MAX_CONSECUTIVE_FRAMING_FAILURES = 3;
+// Task results get written back onto these task objects as the run
+// progresses — hash/hashDetails/timestamps by hashing and the orchestrator,
+// terminalOutput by the Nx Cloud life cycle (untyped) — so a later message
+// would otherwise re-ship every earlier result.
+function withoutTaskResults(tasks, taskGraph) {
+    const pruned = (0, prune_task_graph_1.pruneTaskGraph)(taskGraph);
+    return { tasks: tasks.map((t) => pruned.tasks[t.id]), taskGraph: pruned };
+}
 class DaemonClient {
     constructor() {
         // Tracks the spinner owned by the in-flight request so streamed
@@ -201,21 +211,21 @@ class DaemonClient {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });
     }
     hashTasks(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
-        // Task results get written back onto these task objects as the run
-        // progresses — hash/hashDetails/timestamps by hashing and the
-        // orchestrator, terminalOutput by the Nx Cloud life cycle (untyped) —
-        // so a later message would otherwise re-ship every earlier result.
-        const trimmedTasks = {};
-        for (const [id, t] of Object.entries(taskGraph.tasks)) {
-            const { hash, hashDetails, startTime, endTime, terminalOutput, ...strippedTask } = t;
-            trimmedTasks[id] = strippedTask;
-        }
         return this.sendToDaemonViaQueue({
             type: 'HASH_TASKS',
             runnerOptions,
             perTaskEnvs,
-            tasks: tasks.map((t) => trimmedTasks[t.id]),
-            taskGraph: { ...taskGraph, tasks: trimmedTasks },
+            ...withoutTaskResults(tasks, taskGraph),
+            cwd,
+            collectInputs,
+        });
+    }
+    hashTasksUpfront(runnerOptions, tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        return this.sendToDaemonViaQueue({
+            type: 'HASH_TASKS_UPFRONT',
+            runnerOptions,
+            perTaskEnvs,
+            ...withoutTaskResults(tasks, taskGraph),
             cwd,
             collectInputs,
         });
@@ -709,6 +719,12 @@ class DaemonClient {
         };
         return this.sendToDaemonViaQueue(message);
     }
+    getPluginCapabilities() {
+        const message = {
+            type: get_plugin_capabilities_1.GET_PLUGIN_CAPABILITIES,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
         const message = {
             type: update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT,

package/dist/src/daemon/message-types/get-plugin-capabilities.d.ts

@@ -0,0 +1,5 @@
+export declare const GET_PLUGIN_CAPABILITIES: 'GET_PLUGIN_CAPABILITIES';
+export type HandleGetPluginCapabilitiesMessage = {
+    type: typeof GET_PLUGIN_CAPABILITIES;
+};
+export declare function isHandleGetPluginCapabilitiesMessage(message: unknown): message is HandleGetPluginCapabilitiesMessage;

package/dist/src/daemon/message-types/get-plugin-capabilities.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_PLUGIN_CAPABILITIES = void 0;
+exports.isHandleGetPluginCapabilitiesMessage = isHandleGetPluginCapabilitiesMessage;
+exports.GET_PLUGIN_CAPABILITIES = 'GET_PLUGIN_CAPABILITIES';
+function isHandleGetPluginCapabilitiesMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_PLUGIN_CAPABILITIES);
+}

package/dist/src/daemon/message-types/run-tasks-execution-hooks.d.ts

@@ -1,4 +1,5 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins';
+import type { PreTasksExecutionContext } from '../../project-graph/plugins';
+import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/plugins/task-results-stub';
 export declare const PRE_TASKS_EXECUTION: 'PRE_TASKS_EXECUTION';
 export declare const POST_TASKS_EXECUTION: 'POST_TASKS_EXECUTION';
 export type HandlePreTasksExecutionMessage = {
@@ -7,7 +8,7 @@ export type HandlePreTasksExecutionMessage = {
 };
 export type HandlePostTasksExecutionMessage = {
     type: typeof POST_TASKS_EXECUTION;
-    context: PostTasksExecutionContext;
+    context: MaybeStubbedPostTasksExecutionContext;
 };
 export declare function isHandlePreTasksExecutionMessage(message: unknown): message is HandlePreTasksExecutionMessage;
 export declare function isHandlePostTasksExecutionMessage(message: unknown): message is HandlePostTasksExecutionMessage;

package/dist/src/daemon/server/handle-get-plugin-capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleGetPluginCapabilities(): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-get-plugin-capabilities.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetPluginCapabilities = handleGetPluginCapabilities;
+const nx_json_1 = require("../../config/nx-json");
+const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleGetPluginCapabilities() {
+    const plugins = await (0, get_plugins_1.getPlugins)((0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot), workspace_root_1.workspaceRoot);
+    return {
+        response: plugins.map((plugin) => plugin.capabilities()),
+        description: 'handleGetPluginCapabilities',
+    };
+}

package/dist/src/daemon/server/handle-hash-tasks.d.ts

@@ -1,12 +1,18 @@
 import { Task, TaskGraph } from '../../config/task-graph';
-export declare function handleHashTasks(payload: {
+interface HashTasksPayload {
     runnerOptions: any;
     tasks: Task[];
     taskGraph: TaskGraph;
     perTaskEnvs: Record<string, NodeJS.ProcessEnv>;
     cwd: string;
     collectInputs?: boolean;
-}): Promise<{
+}
+export declare function handleHashTasks(payload: HashTasksPayload): Promise<{
     response: import("../../hasher/task-hasher").Hash[];
     description: string;
 }>;
+export declare function handleHashTasksUpfront(payload: HashTasksPayload): Promise<{
+    response: Record<string, import("../../hasher/task-hasher").Hash>;
+    description: string;
+}>;
+export {};

package/dist/src/daemon/server/handle-hash-tasks.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleHashTasks = handleHashTasks;
+exports.handleHashTasksUpfront = handleHashTasksUpfront;
 const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
 const task_hasher_1 = require("../../hasher/task-hasher");
 const configuration_1 = require("../../config/configuration");
@@ -10,7 +11,7 @@ const configuration_1 = require("../../config/configuration");
  */
 let storedProjectGraph = null;
 let storedHasher = null;
-async function handleHashTasks(payload) {
+async function getHasher(runnerOptions) {
     const { error, projectGraph, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
     if (error) {
         throw error;
@@ -18,11 +19,23 @@ async function handleHashTasks(payload) {
     const nxJson = (0, configuration_1.readNxJson)();
     if (projectGraph !== storedProjectGraph) {
         storedProjectGraph = projectGraph;
-        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, payload.runnerOptions);
+        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, runnerOptions);
     }
-    const response = await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
+    return storedHasher;
+}
+async function handleHashTasks(payload) {
+    const hasher = await getHasher(payload.runnerOptions);
+    const response = await hasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
     return {
         response,
         description: 'handleHashTasks',
     };
 }
+async function handleHashTasksUpfront(payload) {
+    const hasher = await getHasher(payload.runnerOptions);
+    const response = await hasher.hashTasksUpfront(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
+    return {
+        response,
+        description: 'handleHashTasksUpfront',
+    };
+}

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

@@ -1,4 +1,4 @@
-import type { FileWatcherCallback } from './watcher';
+import { type WatchEventsListener } from '../../utils/workspace-context';
 /**
  * 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
@@ -7,4 +7,4 @@ import type { FileWatcherCallback } from './watcher';
  * a workspace watcher error.
  */
 export declare function getOutputsWatcherTerminalError(): Error | undefined;
-export declare const handleOutputsChanges: FileWatcherCallback;
+export declare const handleOutputsChanges: WatchEventsListener;

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

@@ -6,6 +6,8 @@ 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");
+const workspace_root_1 = require("../../utils/workspace-root");
+const workspace_context_1 = require("../../utils/workspace-context");
 let outputsWatcherError;
 let outputsWatcherTerminalError;
 /**
@@ -38,6 +40,15 @@ const handleOutputsChanges = async (err, changeEvents) => {
             }
             return;
         }
+        if (changeEvents.some((event) => event.type === 'rescan')) {
+            // Dropped events cannot be classified: any recorded output hash and any
+            // gitignored dotenv file may have changed unseen. Start the tracker
+            // over and invalidate the graph rather than trust either.
+            logger_1.serverLogger.watcherLog('The outputs watcher reported dropped events; clearing recorded output hashes and invalidating the graph cache.');
+            (0, outputs_tracking_1.clearRecordedOutputsHashes)();
+            (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
+            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
@@ -47,11 +58,11 @@ const handleOutputsChanges = async (err, changeEvents) => {
         // 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
+        // and only the pre-serve replay can prove that. The context answers from
+        // the files the watch keeps, so a path it does not hold is gitignored,
+        // already deleted, or not yet ingested, and each of those needs the
+        // invalidation. A missing context answers with nothing, which invalidates
+        // too. 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.
@@ -59,7 +70,11 @@ const handleOutputsChanges = async (err, changeEvents) => {
             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));
+            // Skips the napi call, which takes the files mutex and can wait out a
+            // re-walk, for the common batch that classifies nothing.
+            const knownInvalidating = invalidating.length
+                ? (0, workspace_context_1.trackedFilesInContext)(workspace_root_1.workspaceRoot, invalidating)
+                : [];
             (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(knownInvalidating, generation);
             if (knownInvalidating.length < invalidating.length) {
                 (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();

package/dist/src/daemon/server/handle-tasks-execution-hooks.d.ts

@@ -1,4 +1,5 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import type { PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
+import type { MaybeStubbedPostTasksExecutionContext } from '../../project-graph/plugins/task-results-stub';
 export declare function handleRunPreTasksExecution(context: PreTasksExecutionContext): Promise<{
     response: NodeJS.ProcessEnv[];
     description: string;
@@ -8,7 +9,7 @@ export declare function handleRunPreTasksExecution(context: PreTasksExecutionCon
     error: any;
     description: string;
 }>;
-export declare function handleRunPostTasksExecution(context: PostTasksExecutionContext): Promise<{
+export declare function handleRunPostTasksExecution(context: MaybeStubbedPostTasksExecutionContext): Promise<{
     error?: undefined;
     response: string;
     description: string;

package/dist/src/daemon/server/outputs-tracking.d.ts

@@ -20,4 +20,10 @@ export declare function recordOutputsHashBatch(entries: {
     outputs: string[];
     hash: string;
 }[]): void;
+/**
+ * One-shot reset for a watcher rescan: recorded hashes may describe outputs
+ * whose change events were dropped, so none can be trusted. Unlike
+ * `disableOutputsTracking` the tracker keeps running; it just starts over.
+ */
+export declare function clearRecordedOutputsHashes(): void;
 export declare function disableOutputsTracking(): void;

package/dist/src/daemon/server/outputs-tracking.js

@@ -5,6 +5,7 @@ exports._outputsHashesMatch = _outputsHashesMatch;
 exports.processFileChangesInOutputs = processFileChangesInOutputs;
 exports.outputsHashesMatchBatch = outputsHashesMatchBatch;
 exports.recordOutputsHashBatch = recordOutputsHashBatch;
+exports.clearRecordedOutputsHashes = clearRecordedOutputsHashes;
 exports.disableOutputsTracking = disableOutputsTracking;
 const path_1 = require("path");
 const native_1 = require("../../native");
@@ -115,6 +116,23 @@ function recordOutputsHashBatch(entries) {
         _recordOutputsHash(expanded, entries[i].hash);
     }
 }
+/**
+ * One-shot reset for a watcher rescan: recorded hashes may describe outputs
+ * whose change events were dropped, so none can be trusted. Unlike
+ * `disableOutputsTracking` the tracker keeps running; it just starts over.
+ */
+function clearRecordedOutputsHashes() {
+    for (const store of [
+        dirsContainingOutputs,
+        recordedHashes,
+        timestamps,
+        numberOfExpandedOutputs,
+    ]) {
+        for (const key of Object.keys(store)) {
+            delete store[key];
+        }
+    }
+}
 function disableOutputsTracking() {
     disabled = true;
 }

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

@@ -1,6 +1,7 @@
 import { Socket } from 'net';
 import { FileMap, ProjectGraph } from '../../config/project-graph';
 import { NxWorkspaceFilesExternals } from '../../native';
+import type { ChangeBatch } from '../../native';
 import { FileMapCache } from '../../project-graph/nx-deps-cache';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration/source-maps';
 interface SerializedProjectGraph {
@@ -20,7 +21,28 @@ export declare let currentProjectFileMapCache: FileMapCache | undefined;
 export declare let currentProjectGraph: ProjectGraph | undefined;
 export declare let currentSourceMaps: ConfigurationSourceMaps | undefined;
 export declare function getCachedSerializedProjectGraphPromise(socket?: Socket): Promise<SerializedProjectGraph>;
+/**
+ * Takes in changes the workspace context handed out: restarts the daemon if
+ * an ignore file changed, otherwise schedules the recomputation.
+ */
+export declare function routeAppliedChanges(batch: ChangeBatch): void;
+/**
+ * Applies everything the workspace watcher has seen and routes what changed.
+ * Call before serving a cached project graph, so a change the watcher already
+ * saw is never missed.
+ */
+export declare function flushPendingWorkspaceChanges(): Promise<void>;
+/**
+ * Applies changes a caller learned of on its own to the workspace context,
+ * then schedules the recomputation as for a batch the context applied.
+ *
+ * The caller is a sync generator, whose writes the watch would report anyway;
+ * this makes them visible before the generator returns rather than by the next
+ * settle. Whether that guarantee is still needed is NXC-4996.
+ */
 export declare function scheduleProjectGraphRecomputation(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
+/** Computes the first project graph, unless one is already on its way. */
+export declare function scheduleInitialProjectGraphComputation(): 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
@@ -37,11 +59,4 @@ export declare function invalidateGraphCache(): void;
  * 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 {};