@ohos-ports/nx 19.8.4-beta.0

package/src/daemon/server/handle-request-project-graph.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestProjectGraph = handleRequestProjectGraph;
+const perf_hooks_1 = require("perf_hooks");
+const socket_utils_1 = require("../socket-utils");
+const logger_1 = require("./logger");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleRequestProjectGraph() {
+    try {
+        perf_hooks_1.performance.mark('server-connection');
+        logger_1.serverLogger.requestLog('Client Request for Project Graph Received');
+        const result = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        if (result.error) {
+            return {
+                description: `Error when preparing serialized project graph.`,
+                error: result.error,
+            };
+        }
+        const serializedResult = (0, socket_utils_1.serializeResult)(result.error, result.serializedProjectGraph, result.serializedSourceMaps);
+        if (!serializedResult) {
+            return {
+                description: `Error when serializing project graph result.`,
+                error: new Error('Critical error when serializing server result, check server logs'),
+            };
+        }
+        perf_hooks_1.performance.mark('serialized-project-graph-ready');
+        perf_hooks_1.performance.measure('total for creating and serializing project graph', 'server-connection', 'serialized-project-graph-ready');
+        return { response: serializedResult, description: 'project-graph' };
+    }
+    catch (e) {
+        return {
+            description: `Unexpected error when creating Project Graph.`,
+            error: e,
+        };
+    }
+}

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

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

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

@@ -0,0 +1,27 @@
+"use strict";
+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) {
+        return {
+            description: `Unable to shutdown the daemon. ${numberOfConnections} connections are open.`,
+            response: '{}',
+        };
+    }
+    else {
+        setTimeout(async () => {
+            await (0, shutdown_utils_1.handleServerProcessTermination)({
+                server,
+                reason: 'Request to shutdown',
+                sockets: server_1.openSockets,
+            });
+        }, 0);
+        return {
+            description: 'Shutdown initiated',
+            response: '{}',
+        };
+    }
+}

package/src/daemon/server/handle-task-history.d.ts

@@ -0,0 +1,13 @@
+import type { TaskRun, TaskTarget } from '../../native';
+export declare function handleRecordTaskRuns(taskRuns: TaskRun[]): Promise<{
+    response: string;
+    description: string;
+}>;
+export declare function handleGetFlakyTasks(hashes: string[]): Promise<{
+    response: string;
+    description: string;
+}>;
+export declare function handleGetEstimatedTaskTimings(targets: TaskTarget[]): Promise<{
+    response: string;
+    description: string;
+}>;

package/src/daemon/server/handle-task-history.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRecordTaskRuns = handleRecordTaskRuns;
+exports.handleGetFlakyTasks = handleGetFlakyTasks;
+exports.handleGetEstimatedTaskTimings = handleGetEstimatedTaskTimings;
+const task_history_1 = require("../../utils/task-history");
+async function handleRecordTaskRuns(taskRuns) {
+    const taskHistory = (0, task_history_1.getTaskHistory)();
+    await taskHistory.recordTaskRuns(taskRuns);
+    return {
+        response: 'true',
+        description: 'handleRecordTaskRuns',
+    };
+}
+async function handleGetFlakyTasks(hashes) {
+    const taskHistory = (0, task_history_1.getTaskHistory)();
+    const history = await taskHistory.getFlakyTasks(hashes);
+    return {
+        response: JSON.stringify(history),
+        description: 'handleGetFlakyTasks',
+    };
+}
+async function handleGetEstimatedTaskTimings(targets) {
+    const taskHistory = (0, task_history_1.getTaskHistory)();
+    const history = await taskHistory.getEstimatedTaskTimings(targets);
+    return {
+        response: JSON.stringify(history),
+        description: 'handleGetEstimatedTaskTimings',
+    };
+}

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/logger.d.ts

@@ -0,0 +1,18 @@
+/**
+ * To improve the overall readibility of the logs, we categorize things by "trigger":
+ *
+ * - [REQUEST] meaning that the current set of actions were triggered by a client request to the server
+ * - [WATCHER] meaning the the current set of actions were triggered by handling changes to the workspace files
+ *
+ * We keep those two "triggers" left aligned at the top level and then indent subsequent logs so that there is a
+ * logical hierarchy/grouping.
+ */
+declare class ServerLogger {
+    log(...s: unknown[]): void;
+    requestLog(...s: unknown[]): void;
+    watcherLog(...s: unknown[]): void;
+    private formatLogMessage;
+    private getNow;
+}
+export declare const serverLogger: ServerLogger;
+export {};

package/src/daemon/server/logger.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * To improve the overall readibility of the logs, we categorize things by "trigger":
+ *
+ * - [REQUEST] meaning that the current set of actions were triggered by a client request to the server
+ * - [WATCHER] meaning the the current set of actions were triggered by handling changes to the workspace files
+ *
+ * We keep those two "triggers" left aligned at the top level and then indent subsequent logs so that there is a
+ * logical hierarchy/grouping.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverLogger = void 0;
+class ServerLogger {
+    log(...s) {
+        console.log(this.formatLogMessage(`${s
+            .map((val) => {
+            if (typeof val === 'string') {
+                return val;
+            }
+            return JSON.stringify(val);
+        })
+            .join(' ')}`));
+    }
+    requestLog(...s) {
+        this.log(`[REQUEST]: ${s.join(' ')}`);
+    }
+    watcherLog(...s) {
+        this.log(`[WATCHER]: ${s.join(' ')}`);
+    }
+    formatLogMessage(message) {
+        return `[NX Daemon Server] - ${this.getNow()} - ${message}`;
+    }
+    getNow() {
+        return new Date(Date.now()).toISOString();
+    }
+}
+exports.serverLogger = new ServerLogger();

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

@@ -0,0 +1,8 @@
+import { WatchEvent } from '../../native';
+export declare function _recordOutputsHash(outputs: string[], hash: string): void;
+export declare function _outputsHashesMatch(outputs: string[], hash: string): boolean;
+export declare function recordedHash(output: string): string;
+export declare function recordOutputsHash(_outputs: string[], hash: string): Promise<void>;
+export declare function outputsHashesMatch(_outputs: string[], hash: string): Promise<boolean>;
+export declare function processFileChangesInOutputs(changeEvents: WatchEvent[], now?: number): void;
+export declare function disableOutputsTracking(): void;

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._recordOutputsHash = _recordOutputsHash;
+exports._outputsHashesMatch = _outputsHashesMatch;
+exports.recordedHash = recordedHash;
+exports.recordOutputsHash = recordOutputsHash;
+exports.outputsHashesMatch = outputsHashesMatch;
+exports.processFileChangesInOutputs = processFileChangesInOutputs;
+exports.disableOutputsTracking = disableOutputsTracking;
+const path_1 = require("path");
+const native_1 = require("../../native");
+const collapse_expanded_outputs_1 = require("../../utils/collapse-expanded-outputs");
+const workspace_root_1 = require("../../utils/workspace-root");
+let disabled = false;
+const dirsContainingOutputs = {};
+const recordedHashes = {};
+const timestamps = {};
+const numberOfExpandedOutputs = {};
+function _recordOutputsHash(outputs, hash) {
+    numberOfExpandedOutputs[hash] = outputs.length;
+    for (const output of outputs) {
+        recordedHashes[output] = hash;
+        timestamps[output] = new Date().getTime();
+        let current = output;
+        while (current != (0, path_1.dirname)(current)) {
+            if (!dirsContainingOutputs[current]) {
+                dirsContainingOutputs[current] = new Set();
+            }
+            dirsContainingOutputs[current].add(output);
+            current = (0, path_1.dirname)(current);
+        }
+    }
+}
+function _outputsHashesMatch(outputs, hash) {
+    if (outputs.length !== numberOfExpandedOutputs[hash]) {
+        return false;
+    }
+    else {
+        for (const output of outputs) {
+            if (recordedHashes[output] !== hash) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function recordedHash(output) {
+    return recordedHashes[output];
+}
+async function recordOutputsHash(_outputs, hash) {
+    const outputs = await normalizeOutputs(_outputs);
+    if (disabled)
+        return;
+    _recordOutputsHash(outputs, hash);
+}
+async function outputsHashesMatch(_outputs, hash) {
+    const outputs = await normalizeOutputs(_outputs);
+    if (disabled)
+        return false;
+    return _outputsHashesMatch(outputs, hash);
+}
+async function normalizeOutputs(outputs) {
+    let expandedOutputs = (0, collapse_expanded_outputs_1.collapseExpandedOutputs)((0, native_1.getFilesForOutputs)(workspace_root_1.workspaceRoot, outputs));
+    return expandedOutputs;
+}
+function processFileChangesInOutputs(changeEvents, now = undefined) {
+    if (!now) {
+        now = new Date().getTime();
+    }
+    for (let e of changeEvents) {
+        let current = e.path;
+        // the path is either an output itself or a parent
+        if (dirsContainingOutputs[current]) {
+            dirsContainingOutputs[current].forEach((output) => {
+                if (now - timestamps[output] > 2000) {
+                    recordedHashes[output] = undefined;
+                }
+            });
+            continue;
+        }
+        // the path is a child of some output or unrelated
+        while (current != (0, path_1.dirname)(current)) {
+            if (recordedHashes[current] && now - timestamps[current] > 2000) {
+                recordedHashes[current] = undefined;
+                break;
+            }
+            current = (0, path_1.dirname)(current);
+        }
+    }
+}
+function disableOutputsTracking() {
+    disabled = true;
+}

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

@@ -0,0 +1,3 @@
+import { LoadedNxPlugin } from '../../project-graph/plugins/internal-api';
+export declare function getPlugins(): Promise<LoadedNxPlugin[]>;
+export declare function cleanupPlugins(): void;

package/src/daemon/server/plugins.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlugins = getPlugins;
+exports.cleanupPlugins = cleanupPlugins;
+const file_hasher_1 = require("../../hasher/file-hasher");
+const nx_json_1 = require("../../config/nx-json");
+const internal_api_1 = require("../../project-graph/plugins/internal-api");
+const workspace_root_1 = require("../../utils/workspace-root");
+let currentPluginsConfigurationHash;
+let loadedPlugins;
+let cleanup;
+async function getPlugins() {
+    const pluginsConfiguration = (0, nx_json_1.readNxJson)().plugins ?? [];
+    const pluginsConfigurationHash = (0, file_hasher_1.hashObject)(pluginsConfiguration);
+    // If the plugins configuration has not changed, reuse the current plugins
+    if (loadedPlugins &&
+        pluginsConfigurationHash === currentPluginsConfigurationHash) {
+        return loadedPlugins;
+    }
+    // Cleanup current plugins before loading new ones
+    if (cleanup) {
+        cleanup();
+    }
+    currentPluginsConfigurationHash = pluginsConfigurationHash;
+    const [result, cleanupFn] = await (0, internal_api_1.loadNxPlugins)(pluginsConfiguration, workspace_root_1.workspaceRoot);
+    cleanup = cleanupFn;
+    loadedPlugins = result;
+    return result;
+}
+function cleanupPlugins() {
+    cleanup();
+}

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

@@ -0,0 +1,24 @@
+import { FileData, FileMap, ProjectGraph } from '../../config/project-graph';
+import { FileMapCache } from '../../project-graph/nx-deps-cache';
+import { NxWorkspaceFilesExternals } from '../../native';
+interface SerializedProjectGraph {
+    error: Error | null;
+    projectGraph: ProjectGraph | null;
+    projectFileMapCache: FileMapCache | null;
+    fileMap: FileMap | null;
+    allWorkspaceFiles: FileData[] | null;
+    serializedProjectGraph: string | null;
+    serializedSourceMaps: string | null;
+    rustReferences: NxWorkspaceFilesExternals | null;
+}
+export declare let fileMapWithFiles: {
+    fileMap: FileMap;
+    allWorkspaceFiles: FileData[];
+    rustReferences: NxWorkspaceFilesExternals;
+} | undefined;
+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

@@ -0,0 +1,300 @@
+"use strict";
+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");
+const build_project_graph_1 = require("../../project-graph/build-project-graph");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const nx_deps_cache_1 = require("../../project-graph/nx-deps-cache");
+const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+const file_watcher_sockets_1 = require("./file-watching/file-watcher-sockets");
+const logger_1 = require("./logger");
+const plugins_1 = require("./plugins");
+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;
+        }
+        // reset the wait time
+        waitPeriod = 100;
+        await resetInternalStateIfNxDepsMissing();
+        const plugins = await (0, plugins_1.getPlugins)();
+        if (collectedUpdatedFiles.size == 0 && collectedDeletedFiles.size == 0) {
+            if (!cachedSerializedProjectGraphPromise) {
+                cachedSerializedProjectGraphPromise =
+                    processFilesAndCreateAndSerializeProjectGraph(plugins);
+            }
+        }
+        else {
+            cachedSerializedProjectGraphPromise =
+                processFilesAndCreateAndSerializeProjectGraph(plugins);
+        }
+        const result = await cachedSerializedProjectGraphPromise;
+        if (wasScheduled) {
+            notifyProjectGraphRecomputationListeners(result.projectGraph);
+        }
+        return result;
+    }
+    catch (e) {
+        return {
+            error: e,
+            serializedProjectGraph: null,
+            serializedSourceMaps: null,
+            projectGraph: null,
+            projectFileMapCache: null,
+            fileMap: null,
+            allWorkspaceFiles: null,
+            rustReferences: null,
+        };
+    }
+}
+function addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles) {
+    for (let f of [...createdFiles, ...updatedFiles]) {
+        collectedDeletedFiles.delete(f);
+        collectedUpdatedFiles.add(f);
+    }
+    for (let f of deletedFiles) {
+        collectedUpdatedFiles.delete(f);
+        collectedDeletedFiles.add(f);
+    }
+    if (updatedFiles.length > 0 || deletedFiles.length > 0) {
+        (0, file_watcher_sockets_1.notifyFileWatcherSockets)(null, updatedFiles, deletedFiles);
+    }
+    if (createdFiles.length > 0) {
+        waitPeriod = 100; // reset it to process the graph faster
+    }
+    if (!scheduledTimeoutId) {
+        scheduledTimeoutId = setTimeout(async () => {
+            scheduledTimeoutId = undefined;
+            if (waitPeriod < 4000) {
+                waitPeriod = waitPeriod * 2;
+            }
+            cachedSerializedProjectGraphPromise =
+                processFilesAndCreateAndSerializeProjectGraph(await (0, plugins_1.getPlugins)());
+            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))
+        .map(([projectName, projectConfig]) => `${projectName}:${JSON.stringify(projectConfig)}`);
+    return (0, file_hasher_1.hashArray)(projectConfigurationStrings);
+}
+async function processCollectedUpdatedAndDeletedFiles({ projects, externalNodes, projectRootMap }, updatedFileHashes, deletedFiles) {
+    try {
+        const workspaceConfigHash = computeWorkspaceConfigHash(projects);
+        // when workspace config changes we cannot incrementally update project file map
+        if (workspaceConfigHash !== storedWorkspaceConfigHash) {
+            storedWorkspaceConfigHash = workspaceConfigHash;
+            ({ ...exports.fileMapWithFiles } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap));
+            knownExternalNodes = externalNodes;
+        }
+        else {
+            if (exports.fileMapWithFiles) {
+                exports.fileMapWithFiles = (0, file_map_utils_1.updateFileMap)(projects, exports.fileMapWithFiles.rustReferences, updatedFileHashes, deletedFiles);
+            }
+            else {
+                exports.fileMapWithFiles = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+            }
+        }
+        collectedUpdatedFiles.clear();
+        collectedDeletedFiles.clear();
+    }
+    catch (e) {
+        // this is expected
+        // for instance, project.json can be incorrect or a file we are trying to has
+        // has been deleted
+        // we are resetting internal state to start from scratch next time a file changes
+        // given the user the opportunity to fix the error
+        // if Nx requests the project graph prior to the error being fixed,
+        // the error will be propagated
+        logger_1.serverLogger.log(`Error detected when recomputing project file map: ${e.message}`);
+        resetInternalState();
+        throw e;
+    }
+}
+async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
+    try {
+        perf_hooks_1.performance.mark('hash-watched-changes-start');
+        const updatedFiles = [...collectedUpdatedFiles.values()];
+        const deletedFiles = [...collectedDeletedFiles.values()];
+        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...`);
+        logger_1.serverLogger.requestLog([...updatedFiles.values()]);
+        logger_1.serverLogger.requestLog([...deletedFiles]);
+        const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
+        global.NX_GRAPH_CREATION = true;
+        let projectConfigurationsResult;
+        let projectConfigurationsError;
+        try {
+            projectConfigurationsResult = await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, workspace_root_1.workspaceRoot, nxJson);
+        }
+        catch (e) {
+            if (e instanceof error_types_1.ProjectConfigurationsError) {
+                projectConfigurationsResult = e.partialProjectConfigurationsResult;
+                projectConfigurationsError = e;
+            }
+            else {
+                throw e;
+            }
+        }
+        await processCollectedUpdatedAndDeletedFiles(projectConfigurationsResult, updatedFileHashes, deletedFiles);
+        const g = await createAndSerializeProjectGraph(projectConfigurationsResult);
+        delete global.NX_GRAPH_CREATION;
+        const errors = [...(projectConfigurationsError?.errors ?? [])];
+        if (g.error) {
+            if ((0, error_types_1.isAggregateProjectGraphError)(g.error) && g.error.errors?.length) {
+                errors.push(...g.error.errors);
+            }
+            else {
+                return {
+                    error: g.error,
+                    projectGraph: null,
+                    projectFileMapCache: null,
+                    fileMap: null,
+                    rustReferences: null,
+                    allWorkspaceFiles: null,
+                    serializedProjectGraph: null,
+                    serializedSourceMaps: null,
+                };
+            }
+        }
+        if (errors.length > 0) {
+            return {
+                error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps),
+                projectGraph: null,
+                projectFileMapCache: null,
+                fileMap: null,
+                rustReferences: null,
+                allWorkspaceFiles: null,
+                serializedProjectGraph: null,
+                serializedSourceMaps: null,
+            };
+        }
+        else {
+            (0, nx_deps_cache_1.writeCache)(g.projectFileMapCache, g.projectGraph);
+            return g;
+        }
+    }
+    catch (err) {
+        return {
+            error: err,
+            projectGraph: null,
+            projectFileMapCache: null,
+            fileMap: null,
+            rustReferences: null,
+            allWorkspaceFiles: null,
+            serializedProjectGraph: null,
+            serializedSourceMaps: null,
+        };
+    }
+}
+function copyFileData(d) {
+    return d.map((t) => ({ ...t }));
+}
+function copyFileMap(m) {
+    const c = {
+        nonProjectFiles: copyFileData(m.nonProjectFiles),
+        projectFileMap: {},
+    };
+    for (let p of Object.keys(m.projectFileMap)) {
+        c.projectFileMap[p] = copyFileData(m.projectFileMap[p]);
+    }
+    return c;
+}
+async function createAndSerializeProjectGraph({ projects, sourceMaps, }) {
+    try {
+        perf_hooks_1.performance.mark('create-project-graph-start');
+        const fileMap = copyFileMap(exports.fileMapWithFiles.fileMap);
+        const allWorkspaceFiles = copyFileData(exports.fileMapWithFiles.allWorkspaceFiles);
+        const rustReferences = exports.fileMapWithFiles.rustReferences;
+        const { projectGraph, projectFileMapCache } = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, knownExternalNodes, fileMap, allWorkspaceFiles, rustReferences, exports.currentProjectFileMapCache || (0, nx_deps_cache_1.readFileMapCache)(), await (0, plugins_1.getPlugins)(), sourceMaps);
+        exports.currentProjectFileMapCache = projectFileMapCache;
+        exports.currentProjectGraph = projectGraph;
+        perf_hooks_1.performance.mark('create-project-graph-end');
+        perf_hooks_1.performance.measure('total execution time for createProjectGraph()', 'create-project-graph-start', 'create-project-graph-end');
+        perf_hooks_1.performance.mark('json-stringify-start');
+        const serializedProjectGraph = JSON.stringify(projectGraph);
+        const serializedSourceMaps = JSON.stringify(sourceMaps);
+        perf_hooks_1.performance.mark('json-stringify-end');
+        perf_hooks_1.performance.measure('serialize graph', 'json-stringify-start', 'json-stringify-end');
+        return {
+            error: null,
+            projectGraph,
+            projectFileMapCache,
+            fileMap,
+            allWorkspaceFiles,
+            serializedProjectGraph,
+            serializedSourceMaps,
+            rustReferences,
+        };
+    }
+    catch (e) {
+        logger_1.serverLogger.log(`Error detected when creating a project graph: ${e.message}`);
+        return {
+            error: e,
+            projectGraph: null,
+            projectFileMapCache: null,
+            fileMap: null,
+            allWorkspaceFiles: null,
+            serializedProjectGraph: null,
+            serializedSourceMaps: null,
+            rustReferences: null,
+        };
+    }
+}
+async function resetInternalState() {
+    cachedSerializedProjectGraphPromise = undefined;
+    exports.fileMapWithFiles = undefined;
+    exports.currentProjectFileMapCache = undefined;
+    exports.currentProjectGraph = undefined;
+    collectedUpdatedFiles.clear();
+    collectedDeletedFiles.clear();
+    (0, workspace_context_1.resetWorkspaceContext)();
+    waitPeriod = 100;
+}
+async function resetInternalStateIfNxDepsMissing() {
+    try {
+        if (!(0, fileutils_1.fileExists)(nx_deps_cache_1.nxProjectGraph) && cachedSerializedProjectGraphPromise) {
+            await resetInternalState();
+        }
+    }
+    catch (e) {
+        await resetInternalState();
+    }
+}
+function notifyProjectGraphRecomputationListeners(projectGraph) {
+    for (const listener of projectGraphRecomputationListeners) {
+        listener(projectGraph);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { Server, Socket } from 'net';
+export type HandlerResult = {
+    description: string;
+    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>;