nx 19.6.0-canary.20240809-d3747e0 → 19.6.0-canary.20240814-6d83ae2

package/src/daemon/cache.d.ts

@@ -5,5 +5,6 @@ export declare const serverProcessJsonPath: string;
 export declare function readDaemonProcessJsonCache(): Promise<DaemonProcessJson | null>;
 export declare function deleteDaemonJsonProcessCache(): void;
 export declare function writeDaemonJsonProcessCache(daemonJson: DaemonProcessJson): Promise<void>;
+export declare function waitForDaemonToExitAndCleanupProcessJson(): Promise<void>;
 export declare function safelyCleanUpExistingProcess(): Promise<void>;
 export declare function getDaemonProcessIdSync(): number | null;

package/src/daemon/cache.js

@@ -4,6 +4,7 @@ exports.serverProcessJsonPath = void 0;
 exports.readDaemonProcessJsonCache = readDaemonProcessJsonCache;
 exports.deleteDaemonJsonProcessCache = deleteDaemonJsonProcessCache;
 exports.writeDaemonJsonProcessCache = writeDaemonJsonProcessCache;
+exports.waitForDaemonToExitAndCleanupProcessJson = waitForDaemonToExitAndCleanupProcessJson;
 exports.safelyCleanUpExistingProcess = safelyCleanUpExistingProcess;
 exports.getDaemonProcessIdSync = getDaemonProcessIdSync;
 const fs_extra_1 = require("fs-extra");
@@ -27,33 +28,39 @@ function deleteDaemonJsonProcessCache() {
 async function writeDaemonJsonProcessCache(daemonJson) {
     await (0, fs_extra_1.writeJson)(exports.serverProcessJsonPath, daemonJson);
 }
+async function waitForDaemonToExitAndCleanupProcessJson() {
+    const daemonProcessJson = await readDaemonProcessJsonCache();
+    if (daemonProcessJson && daemonProcessJson.processId) {
+        await new Promise((resolve, reject) => {
+            let count = 0;
+            const interval = setInterval(() => {
+                try {
+                    // sending a signal 0 to a process checks if the process is running instead of actually killing it
+                    process.kill(daemonProcessJson.processId, 0);
+                }
+                catch (e) {
+                    clearInterval(interval);
+                    resolve();
+                }
+                if ((count += 1) > 200) {
+                    clearInterval(interval);
+                    reject(`Daemon process ${daemonProcessJson.processId} didn't exit after 2 seconds.`);
+                }
+            }, 10);
+        });
+        deleteDaemonJsonProcessCache();
+    }
+}
 async function safelyCleanUpExistingProcess() {
     const daemonProcessJson = await readDaemonProcessJsonCache();
     if (daemonProcessJson && daemonProcessJson.processId) {
         try {
             process.kill(daemonProcessJson.processId);
             // we wait for the process to actually shut down before returning
-            await new Promise((resolve, reject) => {
-                let count = 0;
-                const interval = setInterval(() => {
-                    try {
-                        // sending a signal 0 to a process checks if the process is running instead of actually killing it
-                        process.kill(daemonProcessJson.processId, 0);
-                    }
-                    catch (e) {
-                        clearInterval(interval);
-                        resolve();
-                    }
-                    if ((count += 1) > 200) {
-                        clearInterval(interval);
-                        reject(`Daemon process ${daemonProcessJson.processId} didn't exit after 2 seconds.`);
-                    }
-                }, 10);
-            });
+            await waitForDaemonToExitAndCleanupProcessJson();
         }
         catch { }
     }
-    deleteDaemonJsonProcessCache();
 }
 // Must be sync for the help output use case
 function getDaemonProcessIdSync() {

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

@@ -5,6 +5,7 @@ import { Task, TaskGraph } from '../../config/task-graph';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
 import { NxWorkspaceFiles } from '../../native';
 import { TaskRun } from '../../utils/task-history';
+import type { SyncGeneratorChangesResult } from '../../utils/sync-generators';
 export type UnregisterCallback = () => void;
 export type ChangedFile = {
     path: string;
@@ -54,6 +55,10 @@ export declare class DaemonClient {
         [hash: string]: TaskRun[];
     }>;
     writeTaskRunsToHistory(taskRuns: TaskRun[]): Promise<void>;
+    getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
+    flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
+    getRegisteredSyncGenerators(): Promise<string[]>;
+    updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
     isServerAvailable(): Promise<boolean>;
     private sendToDaemonViaQueue;
     private setUpConnection;

package/src/daemon/client/client.js

@@ -25,6 +25,11 @@ const get_nx_workspace_files_1 = require("../message-types/get-nx-workspace-file
 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 hash_glob_1 = require("../message-types/hash-glob");
+const force_shutdown_1 = require("../message-types/force-shutdown");
+const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
+const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const update_workspace_context_1 = require("../message-types/update-workspace-context");
+const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
 const DAEMON_ENV_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -244,6 +249,35 @@ class DaemonClient {
         };
         return this.sendMessageToDaemon(message);
     }
+    getSyncGeneratorChanges(generators) {
+        const message = {
+            type: get_sync_generator_changes_1.GET_SYNC_GENERATOR_CHANGES,
+            generators,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    flushSyncGeneratorChangesToDisk(generators) {
+        const message = {
+            type: flush_sync_generator_changes_to_disk_1.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK,
+            generators,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    getRegisteredSyncGenerators() {
+        const message = {
+            type: get_registered_sync_generators_1.GET_REGISTERED_SYNC_GENERATORS,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
+        const message = {
+            type: update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT,
+            createdFiles,
+            updatedFiles,
+            deletedFiles,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     async isServerAvailable() {
         return new Promise((resolve) => {
             try {
@@ -322,12 +356,18 @@ class DaemonClient {
         else if (this._daemonStatus == DaemonStatus.CONNECTING) {
             await this._waitForDaemonReady;
         }
+        // An open promise isn't enough to keep the event loop
+        // alive, so we set a timeout here and clear it when we hear
+        // back
+        const keepAlive = setTimeout(() => { }, 10 * 60 * 1000);
         return new Promise((resolve, reject) => {
             perf_hooks_1.performance.mark('sendMessageToDaemon-start');
             this.currentMessage = message;
             this.currentResolve = resolve;
             this.currentReject = reject;
             this.socketMessenger.sendMessage(message);
+        }).finally(() => {
+            clearTimeout(keepAlive);
         });
     }
     handleMessage(serializedResult) {
@@ -398,7 +438,8 @@ class DaemonClient {
     }
     async stop() {
         try {
-            await (0, cache_1.safelyCleanUpExistingProcess)();
+            await this.sendMessageToDaemon({ type: force_shutdown_1.FORCE_SHUTDOWN });
+            await (0, cache_1.waitForDaemonToExitAndCleanupProcessJson)();
         }
         catch (err) {
             output_1.output.error({

package/src/daemon/message-types/flush-sync-generator-changes-to-disk.d.ts

@@ -0,0 +1,6 @@
+export declare const FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK: "CLEAR_CACHED_SYNC_GENERATOR_CHANGES";
+export type HandleFlushSyncGeneratorChangesToDiskMessage = {
+    type: typeof FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK;
+    generators: string[];
+};
+export declare function isHandleFlushSyncGeneratorChangesToDiskMessage(message: unknown): message is HandleFlushSyncGeneratorChangesToDiskMessage;

package/src/daemon/message-types/flush-sync-generator-changes-to-disk.js

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

package/src/daemon/message-types/force-shutdown.d.ts

@@ -0,0 +1,5 @@
+export declare const FORCE_SHUTDOWN: "FORCE_SHUTDOWN";
+export type HandleForceShutdownMessage = {
+    type: typeof FORCE_SHUTDOWN;
+};
+export declare function isHandleForceShutdownMessage(message: unknown): message is HandleForceShutdownMessage;

package/src/daemon/message-types/force-shutdown.js

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

package/src/daemon/message-types/get-registered-sync-generators.d.ts

@@ -0,0 +1,5 @@
+export declare const GET_REGISTERED_SYNC_GENERATORS: "GET_REGISTERED_SYNC_GENERATORS";
+export type HandleGetRegisteredSyncGeneratorsMessage = {
+    type: typeof GET_REGISTERED_SYNC_GENERATORS;
+};
+export declare function isHandleGetRegisteredSyncGeneratorsMessage(message: unknown): message is HandleGetRegisteredSyncGeneratorsMessage;

package/src/daemon/message-types/get-registered-sync-generators.js

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

package/src/daemon/message-types/get-sync-generator-changes.d.ts

@@ -0,0 +1,6 @@
+export declare const GET_SYNC_GENERATOR_CHANGES: "GET_SYNC_GENERATOR_CHANGES";
+export type HandleGetSyncGeneratorChangesMessage = {
+    type: typeof GET_SYNC_GENERATOR_CHANGES;
+    generators: string[];
+};
+export declare function isHandleGetSyncGeneratorChangesMessage(message: unknown): message is HandleGetSyncGeneratorChangesMessage;

package/src/daemon/message-types/get-sync-generator-changes.js

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

package/src/daemon/message-types/update-workspace-context.d.ts

@@ -0,0 +1,8 @@
+export declare const UPDATE_WORKSPACE_CONTEXT: "UPDATE_WORKSPACE_CONTEXT";
+export type HandleUpdateWorkspaceContextMessage = {
+    type: typeof UPDATE_WORKSPACE_CONTEXT;
+    createdFiles: string[];
+    updatedFiles: string[];
+    deletedFiles: string[];
+};
+export declare function isHandleUpdateWorkspaceContextMessage(message: unknown): message is HandleUpdateWorkspaceContextMessage;

package/src/daemon/message-types/update-workspace-context.js

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

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.d.ts

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

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFlushSyncGeneratorChangesToDisk = handleFlushSyncGeneratorChangesToDisk;
+const sync_generators_1 = require("./sync-generators");
+async function handleFlushSyncGeneratorChangesToDisk(generators) {
+    await (0, sync_generators_1.flushSyncGeneratorChangesToDisk)(generators);
+    return {
+        response: '{}',
+        description: 'handleFlushSyncGeneratorChangesToDisk',
+    };
+}

package/src/daemon/server/handle-force-shutdown.d.ts

@@ -0,0 +1,5 @@
+import { Server } from 'net';
+export declare function handleForceShutdown(server: Server): Promise<{
+    description: string;
+    response: string;
+}>;

package/src/daemon/server/handle-force-shutdown.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleForceShutdown = handleForceShutdown;
+const shutdown_utils_1 = require("./shutdown-utils");
+const server_1 = require("./server");
+async function handleForceShutdown(server) {
+    setTimeout(async () => {
+        await (0, shutdown_utils_1.handleServerProcessTermination)({
+            server,
+            reason: 'Request to shutdown',
+            sockets: server_1.openSockets,
+        });
+    });
+    return {
+        description: 'Shutdown initiated',
+        response: '{}',
+    };
+}

package/src/daemon/server/handle-get-registered-sync-generators.d.ts

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

package/src/daemon/server/handle-get-registered-sync-generators.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetRegisteredSyncGenerators = handleGetRegisteredSyncGenerators;
+const sync_generators_1 = require("./sync-generators");
+async function handleGetRegisteredSyncGenerators() {
+    const syncGenerators = await (0, sync_generators_1.getCachedRegisteredSyncGenerators)();
+    return {
+        response: JSON.stringify(syncGenerators),
+        description: 'handleGetSyncGeneratorChanges',
+    };
+}

package/src/daemon/server/handle-get-sync-generator-changes.d.ts

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

package/src/daemon/server/handle-get-sync-generator-changes.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetSyncGeneratorChanges = handleGetSyncGeneratorChanges;
+const sync_generators_1 = require("./sync-generators");
+async function handleGetSyncGeneratorChanges(generators) {
+    const changes = await (0, sync_generators_1.getCachedSyncGeneratorChanges)(generators);
+    // strip out the content of the changes and any potential callback
+    const result = changes.map((change) => ({
+        generatorName: change.generatorName,
+        changes: change.changes.map((c) => ({ ...c, content: null })),
+        outOfSyncMessage: change.outOfSyncMessage,
+    }));
+    return {
+        response: JSON.stringify(result),
+        description: 'handleGetSyncGeneratorChanges',
+    };
+}

package/src/daemon/server/handle-request-shutdown.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleRequestShutdown = handleRequestShutdown;
 const shutdown_utils_1 = require("./shutdown-utils");
+const server_1 = require("./server");
 async function handleRequestShutdown(server, numberOfConnections) {
     // 1 connection is the client asking to shut down
     if (numberOfConnections > 1) {
@@ -15,6 +16,7 @@ async function handleRequestShutdown(server, numberOfConnections) {
             await (0, shutdown_utils_1.handleServerProcessTermination)({
                 server,
                 reason: 'Request to shutdown',
+                sockets: server_1.openSockets,
             });
         }, 0);
         return {

package/src/daemon/server/handle-update-workspace-context.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleUpdateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-update-workspace-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdateWorkspaceContext = handleUpdateWorkspaceContext;
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleUpdateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
+    (0, project_graph_incremental_recomputation_1.addUpdatedAndDeletedFiles)(createdFiles, updatedFiles, deletedFiles);
+    return {
+        response: '{}',
+        description: 'handleUpdateContextFiles',
+    };
+}

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

@@ -20,4 +20,5 @@ export declare let currentProjectFileMapCache: FileMapCache | undefined;
 export declare let currentProjectGraph: ProjectGraph | undefined;
 export declare function getCachedSerializedProjectGraphPromise(): Promise<SerializedProjectGraph>;
 export declare function addUpdatedAndDeletedFiles(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
+export declare function registerProjectGraphRecomputationListener(listener: (projectGraph: ProjectGraph) => void): void;
 export {};

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.currentProjectGraph = exports.currentProjectFileMapCache = exports.fileMapWithFiles = void 0;
 exports.getCachedSerializedProjectGraphPromise = getCachedSerializedProjectGraphPromise;
 exports.addUpdatedAndDeletedFiles = addUpdatedAndDeletedFiles;
+exports.registerProjectGraphRecomputationListener = registerProjectGraphRecomputationListener;
 const perf_hooks_1 = require("perf_hooks");
 const nx_json_1 = require("../../config/nx-json");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -20,14 +21,17 @@ const error_types_1 = require("../../project-graph/error-types");
 let cachedSerializedProjectGraphPromise;
 const collectedUpdatedFiles = new Set();
 const collectedDeletedFiles = new Set();
+const projectGraphRecomputationListeners = new Set();
 let storedWorkspaceConfigHash;
 let waitPeriod = 100;
 let scheduledTimeoutId;
 let knownExternalNodes = {};
 async function getCachedSerializedProjectGraphPromise() {
     try {
+        let wasScheduled = false;
         // recomputing it now on demand. we can ignore the scheduled timeout
         if (scheduledTimeoutId) {
+            wasScheduled = true;
             clearTimeout(scheduledTimeoutId);
             scheduledTimeoutId = undefined;
         }
@@ -45,7 +49,11 @@ async function getCachedSerializedProjectGraphPromise() {
             cachedSerializedProjectGraphPromise =
                 processFilesAndCreateAndSerializeProjectGraph(plugins);
         }
-        return await cachedSerializedProjectGraphPromise;
+        const result = await cachedSerializedProjectGraphPromise;
+        if (wasScheduled) {
+            notifyProjectGraphRecomputationListeners(result.projectGraph);
+        }
+        return result;
     }
     catch (e) {
         return {
@@ -83,13 +91,17 @@ function addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles) {
             }
             cachedSerializedProjectGraphPromise =
                 processFilesAndCreateAndSerializeProjectGraph(await (0, plugins_1.getPlugins)());
-            await cachedSerializedProjectGraphPromise;
+            const { projectGraph } = await cachedSerializedProjectGraphPromise;
             if (createdFiles.length > 0) {
                 (0, file_watcher_sockets_1.notifyFileWatcherSockets)(createdFiles, null, null);
             }
+            notifyProjectGraphRecomputationListeners(projectGraph);
         }, waitPeriod);
     }
 }
+function registerProjectGraphRecomputationListener(listener) {
+    projectGraphRecomputationListeners.add(listener);
+}
 function computeWorkspaceConfigHash(projectsConfigurations) {
     const projectConfigurationStrings = Object.entries(projectsConfigurations)
         .sort(([projectNameA], [projectNameB]) => projectNameA.localeCompare(projectNameB))
@@ -134,7 +146,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
         perf_hooks_1.performance.mark('hash-watched-changes-start');
         const updatedFiles = [...collectedUpdatedFiles.values()];
         const deletedFiles = [...collectedDeletedFiles.values()];
-        let updatedFileHashes = (0, workspace_context_1.updateFilesInContext)(updatedFiles, deletedFiles);
+        let updatedFileHashes = (0, workspace_context_1.updateFilesInContext)(workspace_root_1.workspaceRoot, updatedFiles, deletedFiles);
         perf_hooks_1.performance.mark('hash-watched-changes-end');
         perf_hooks_1.performance.measure('hash changed files from watcher', 'hash-watched-changes-start', 'hash-watched-changes-end');
         logger_1.serverLogger.requestLog(`Updated workspace context based on watched changes, recomputing project graph...`);
@@ -281,3 +293,8 @@ async function resetInternalStateIfNxDepsMissing() {
         await resetInternalState();
     }
 }
+function notifyProjectGraphRecomputationListeners(projectGraph) {
+    for (const listener of projectGraphRecomputationListeners) {
+        listener(projectGraph);
+    }
+}

package/src/daemon/server/server.d.ts

@@ -4,5 +4,6 @@ export type HandlerResult = {
     error?: any;
     response?: string;
 };
+export declare const openSockets: Set<Socket>;
 export declare function handleResult(socket: Socket, type: string, hrFn: () => Promise<HandlerResult>): Promise<void>;
 export declare function startServer(): Promise<Server>;

package/src/daemon/server/server.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.openSockets = void 0;
 exports.handleResult = handleResult;
 exports.startServer = startServer;
 const fs_1 = require("fs");
@@ -39,13 +40,26 @@ const handle_hash_glob_1 = require("./handle-hash-glob");
 const task_history_1 = require("../message-types/task-history");
 const handle_get_task_history_1 = require("./handle-get-task-history");
 const handle_write_task_runs_to_history_1 = require("./handle-write-task-runs-to-history");
+const force_shutdown_1 = require("../message-types/force-shutdown");
+const handle_force_shutdown_1 = require("./handle-force-shutdown");
+const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
+const handle_get_sync_generator_changes_1 = require("./handle-get-sync-generator-changes");
+const sync_generators_1 = require("./sync-generators");
+const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const handle_get_registered_sync_generators_1 = require("./handle-get-registered-sync-generators");
+const update_workspace_context_1 = require("../message-types/update-workspace-context");
+const handle_update_workspace_context_1 = require("./handle-update-workspace-context");
+const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
+const handle_flush_sync_generator_changes_to_disk_1 = require("./handle-flush-sync-generator-changes-to-disk");
 let performanceObserver;
 let workspaceWatcherError;
 let outputsWatcherError;
 global.NX_DAEMON = true;
 let numberOfOpenConnections = 0;
+exports.openSockets = new Set();
 const server = (0, net_1.createServer)(async (socket) => {
     numberOfOpenConnections += 1;
+    exports.openSockets.add(socket);
     logger_1.serverLogger.log(`Established a connection. Number of open connections: ${numberOfOpenConnections}`);
     (0, shutdown_utils_1.resetInactivityTimeout)(handleInactivityTimeout);
     if (!performanceObserver) {
@@ -64,6 +78,7 @@ const server = (0, net_1.createServer)(async (socket) => {
     });
     socket.on('close', () => {
         numberOfOpenConnections -= 1;
+        exports.openSockets.delete(socket);
         logger_1.serverLogger.log(`Closed a connection. Number of open connections: ${numberOfOpenConnections}`);
         (0, file_watcher_sockets_1.removeRegisteredFileWatcherSocket)(socket);
     });
@@ -131,6 +146,21 @@ async function handleMessage(socket, data) {
     else if ((0, task_history_1.isHandleWriteTaskRunsToHistoryMessage)(payload)) {
         await handleResult(socket, 'WRITE_TASK_RUNS_TO_HISTORY', () => (0, handle_write_task_runs_to_history_1.handleWriteTaskRunsToHistory)(payload.taskRuns));
     }
+    else if ((0, force_shutdown_1.isHandleForceShutdownMessage)(payload)) {
+        await handleResult(socket, 'FORCE_SHUTDOWN', () => (0, handle_force_shutdown_1.handleForceShutdown)(server));
+    }
+    else if ((0, get_sync_generator_changes_1.isHandleGetSyncGeneratorChangesMessage)(payload)) {
+        await handleResult(socket, get_sync_generator_changes_1.GET_SYNC_GENERATOR_CHANGES, () => (0, handle_get_sync_generator_changes_1.handleGetSyncGeneratorChanges)(payload.generators));
+    }
+    else if ((0, flush_sync_generator_changes_to_disk_1.isHandleFlushSyncGeneratorChangesToDiskMessage)(payload)) {
+        await handleResult(socket, flush_sync_generator_changes_to_disk_1.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK, () => (0, handle_flush_sync_generator_changes_to_disk_1.handleFlushSyncGeneratorChangesToDisk)(payload.generators));
+    }
+    else if ((0, get_registered_sync_generators_1.isHandleGetRegisteredSyncGeneratorsMessage)(payload)) {
+        await handleResult(socket, get_registered_sync_generators_1.GET_REGISTERED_SYNC_GENERATORS, () => (0, handle_get_registered_sync_generators_1.handleGetRegisteredSyncGenerators)());
+    }
+    else if ((0, update_workspace_context_1.isHandleUpdateWorkspaceContextMessage)(payload)) {
+        await handleResult(socket, update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT, () => (0, handle_update_workspace_context_1.handleUpdateWorkspaceContext)(payload.createdFiles, payload.updatedFiles, payload.deletedFiles));
+    }
     else {
         await (0, shutdown_utils_1.respondWithErrorAndExit)(socket, `Invalid payload from the client`, new Error(`Unsupported payload sent to daemon server: ${unparsedPayload}`));
     }
@@ -157,6 +187,7 @@ function handleInactivityTimeout() {
         (0, shutdown_utils_1.handleServerProcessTermination)({
             server,
             reason: `${shutdown_utils_1.SERVER_INACTIVITY_TIMEOUT_MS}ms of inactivity`,
+            sockets: exports.openSockets,
         });
     }
 }
@@ -165,14 +196,17 @@ function registerProcessTerminationListeners() {
         .on('SIGINT', () => (0, shutdown_utils_1.handleServerProcessTermination)({
         server,
         reason: 'received process SIGINT',
+        sockets: exports.openSockets,
     }))
         .on('SIGTERM', () => (0, shutdown_utils_1.handleServerProcessTermination)({
         server,
         reason: 'received process SIGTERM',
+        sockets: exports.openSockets,
     }))
         .on('SIGHUP', () => (0, shutdown_utils_1.handleServerProcessTermination)({
         server,
         reason: 'received process SIGHUP',
+        sockets: exports.openSockets,
     }));
 }
 let existingLockHash;
@@ -235,6 +269,7 @@ const handleWorkspaceChanges = async (err, changeEvents) => {
             await (0, shutdown_utils_1.handleServerProcessTermination)({
                 server,
                 reason: outdatedReason,
+                sockets: exports.openSockets,
             });
             return;
         }
@@ -325,6 +360,10 @@ async function startServer() {
                     if (!(0, shutdown_utils_1.getOutputWatcherInstance)()) {
                         (0, shutdown_utils_1.storeOutputWatcherInstance)(await (0, watcher_1.watchOutputFiles)(handleOutputsChanges));
                     }
+                    // listen for project graph recomputation events to collect and schedule sync generators
+                    (0, project_graph_incremental_recomputation_1.registerProjectGraphRecomputationListener)(sync_generators_1.collectAndScheduleSyncGenerators);
+                    // trigger an initial project graph recomputation
+                    (0, project_graph_incremental_recomputation_1.addUpdatedAndDeletedFiles)([], [], []);
                     return resolve(server);
                 }
                 catch (err) {

package/src/daemon/server/shutdown-utils.d.ts

@@ -8,8 +8,9 @@ export declare function getOutputWatcherInstance(): Watcher;
 interface HandleServerProcessTerminationParams {
     server: Server;
     reason: string;
+    sockets: Iterable<Socket>;
 }
-export declare function handleServerProcessTermination({ server, reason, }: HandleServerProcessTerminationParams): Promise<void>;
+export declare function handleServerProcessTermination({ server, reason, sockets, }: HandleServerProcessTerminationParams): Promise<void>;
 export declare function resetInactivityTimeout(cb: () => void): void;
 export declare function respondToClient(socket: Socket, response: string, description: string): Promise<unknown>;
 export declare function respondWithErrorAndExit(socket: Socket, description: string, error: Error): Promise<void>;

package/src/daemon/server/shutdown-utils.js

@@ -30,11 +30,16 @@ function storeOutputWatcherInstance(instance) {
 function getOutputWatcherInstance() {
     return outputWatcherInstance;
 }
-async function handleServerProcessTermination({ server, reason, }) {
+async function handleServerProcessTermination({ server, reason, sockets, }) {
     try {
-        server.close();
-        (0, cache_1.deleteDaemonJsonProcessCache)();
-        (0, plugins_1.cleanupPlugins)();
+        await new Promise((res) => {
+            server.close(() => {
+                res(null);
+            });
+            for (const socket of sockets) {
+                socket.destroy();
+            }
+        });
         if (watcherInstance) {
             await watcherInstance.stop();
             logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (sources)`);
@@ -43,6 +48,8 @@ async function handleServerProcessTermination({ server, reason, }) {
             await outputWatcherInstance.stop();
             logger_1.serverLogger.watcherLog(`Stopping the watcher for ${workspace_root_1.workspaceRoot} (outputs)`);
         }
+        (0, cache_1.deleteDaemonJsonProcessCache)();
+        (0, plugins_1.cleanupPlugins)();
         logger_1.serverLogger.log(`Server stopped because: "${reason}"`);
     }
     finally {

package/src/daemon/server/sync-generators.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import { type SyncGeneratorChangesResult } from '../../utils/sync-generators';
+export declare function getCachedSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
+export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
+export declare function collectAndScheduleSyncGenerators(projectGraph: ProjectGraph): void;
+export declare function getCachedRegisteredSyncGenerators(): Promise<string[]>;