@ohos-ports/nx 17.3.2-beta.0

package/src/daemon/server/file-watching/file-watcher-sockets.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyFileWatcherSockets = exports.hasRegisteredFileWatcherSockets = exports.removeRegisteredFileWatcherSocket = exports.registeredFileWatcherSockets = void 0;
+const find_matching_projects_1 = require("../../../utils/find-matching-projects");
+const project_graph_utils_1 = require("../../../utils/project-graph-utils");
+const promised_based_queue_1 = require("../../../utils/promised-based-queue");
+const project_graph_incremental_recomputation_1 = require("../project-graph-incremental-recomputation");
+const server_1 = require("../server");
+const changed_projects_1 = require("./changed-projects");
+const queue = new promised_based_queue_1.PromisedBasedQueue();
+exports.registeredFileWatcherSockets = [];
+function removeRegisteredFileWatcherSocket(socket) {
+    exports.registeredFileWatcherSockets = exports.registeredFileWatcherSockets.filter((watcher) => watcher.socket !== socket);
+}
+exports.removeRegisteredFileWatcherSocket = removeRegisteredFileWatcherSocket;
+function hasRegisteredFileWatcherSockets() {
+    return exports.registeredFileWatcherSockets.length > 0;
+}
+exports.hasRegisteredFileWatcherSockets = hasRegisteredFileWatcherSockets;
+function notifyFileWatcherSockets(createdFiles, updatedFiles, deletedFiles) {
+    if (!hasRegisteredFileWatcherSockets()) {
+        return;
+    }
+    queue.sendToQueue(async () => {
+        const projectAndGlobalChanges = (0, changed_projects_1.getProjectsAndGlobalChanges)(createdFiles, updatedFiles, deletedFiles);
+        await Promise.all(exports.registeredFileWatcherSockets.map(({ socket, config }) => {
+            const changedProjects = [];
+            const changedFiles = [];
+            if (config.watchProjects === 'all') {
+                for (const [projectName, projectFiles] of Object.entries(projectAndGlobalChanges.projects)) {
+                    changedProjects.push(projectName);
+                    changedFiles.push(...projectFiles);
+                }
+            }
+            else {
+                const watchedProjects = new Set((0, find_matching_projects_1.findMatchingProjects)(config.watchProjects, project_graph_incremental_recomputation_1.currentProjectGraph.nodes));
+                if (config.includeDependentProjects) {
+                    for (const project of watchedProjects) {
+                        for (const dep of (0, project_graph_utils_1.findAllProjectNodeDependencies)(project, project_graph_incremental_recomputation_1.currentProjectGraph)) {
+                            watchedProjects.add(dep);
+                        }
+                    }
+                }
+                for (const watchedProject of watchedProjects) {
+                    if (!!projectAndGlobalChanges.projects[watchedProject]) {
+                        changedProjects.push(watchedProject);
+                        changedFiles.push(...projectAndGlobalChanges.projects[watchedProject]);
+                    }
+                }
+            }
+            if (config.includeGlobalWorkspaceFiles) {
+                changedFiles.push(...projectAndGlobalChanges.globalFiles);
+            }
+            if (changedProjects.length > 0 || changedFiles.length > 0) {
+                return (0, server_1.handleResult)(socket, 'FILE-WATCH-CHANGED', () => Promise.resolve({
+                    description: 'File watch changed',
+                    response: JSON.stringify({
+                        changedProjects,
+                        changedFiles,
+                    }),
+                }));
+            }
+        }));
+    });
+}
+exports.notifyFileWatcherSockets = notifyFileWatcherSockets;

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

@@ -0,0 +1,10 @@
+import { Task, TaskGraph } from '../../config/task-graph';
+export declare function handleHashTasks(payload: {
+    runnerOptions: any;
+    env: any;
+    tasks: Task[];
+    taskGraph: TaskGraph;
+}): Promise<{
+    response: string;
+    description: string;
+}>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHashTasks = void 0;
+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");
+/**
+ * We use this not to recreated hasher for every hash operation
+ * TaskHasher has a cache inside, so keeping it around results in faster performance
+ */
+let storedProjectGraph = null;
+let storedHasher = null;
+async function handleHashTasks(payload) {
+    const { projectGraph, allWorkspaceFiles, fileMap, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const nxJson = (0, configuration_1.readNxJson)();
+    if (projectGraph !== storedProjectGraph) {
+        storedProjectGraph = projectGraph;
+        storedHasher = new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, payload.runnerOptions);
+    }
+    const response = JSON.stringify(await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.env));
+    return {
+        response,
+        description: 'handleHashTasks',
+    };
+}
+exports.handleHashTasks = handleHashTasks;

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

@@ -0,0 +1,15 @@
+import { HandlerResult } from './server';
+export declare function handleRecordOutputsHash(payload: {
+    type: string;
+    data: {
+        outputs: string[];
+        hash: string;
+    };
+}): Promise<HandlerResult>;
+export declare function handleOutputsHashesMatch(payload: {
+    type: string;
+    data: {
+        outputs: string[];
+        hash: string;
+    };
+}): Promise<HandlerResult>;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOutputsHashesMatch = exports.handleRecordOutputsHash = void 0;
+const outputs_tracking_1 = require("./outputs-tracking");
+async function handleRecordOutputsHash(payload) {
+    try {
+        await (0, outputs_tracking_1.recordOutputsHash)(payload.data.outputs, payload.data.hash);
+        return {
+            description: 'recordOutputsHash',
+            response: '{}',
+        };
+    }
+    catch (e) {
+        return {
+            description: 'recordOutputsHash failed',
+            error: new Error(`Critical error when recording metadata about outputs: '${e.message}'.`),
+        };
+    }
+}
+exports.handleRecordOutputsHash = handleRecordOutputsHash;
+async function handleOutputsHashesMatch(payload) {
+    try {
+        const res = await (0, outputs_tracking_1.outputsHashesMatch)(payload.data.outputs, payload.data.hash);
+        return {
+            response: JSON.stringify(res),
+            description: 'outputsHashesMatch',
+        };
+    }
+    catch (e) {
+        return {
+            description: 'outputsHashesMatch failed',
+            error: new Error(`Critical error when verifying the contents of the outputs haven't changed: '${e.message}'.`),
+        };
+    }
+}
+exports.handleOutputsHashesMatch = handleOutputsHashesMatch;

package/src/daemon/server/handle-process-in-background.d.ts

@@ -0,0 +1,6 @@
+import { HandlerResult } from './server';
+export declare function handleProcessInBackground(payload: {
+    type: string;
+    requirePath: string;
+    data: any;
+}): Promise<HandlerResult>;

package/src/daemon/server/handle-process-in-background.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleProcessInBackground = void 0;
+const logger_1 = require("./logger");
+const installation_directory_1 = require("../../utils/installation-directory");
+async function handleProcessInBackground(payload) {
+    let fn;
+    try {
+        fn = require(require.resolve(payload.requirePath, {
+            paths: (0, installation_directory_1.getNxRequirePaths)(),
+        })).default;
+    }
+    catch (e) {
+        return {
+            description: `Unable to require ${payload.requirePath}`,
+            error: new Error(`Unable to require ${payload.requirePath}`),
+        };
+    }
+    try {
+        const response = await fn(payload.data, logger_1.serverLogger);
+        return {
+            response,
+            description: payload.type,
+        };
+    }
+    catch (e) {
+        return {
+            description: `Error when processing ${payload.type}.`,
+            error: e,
+        };
+    }
+}
+exports.handleProcessInBackground = handleProcessInBackground;

package/src/daemon/server/handle-request-file-data.d.ts

@@ -0,0 +1,4 @@
+export declare function handleRequestFileData(): Promise<{
+    response: string;
+    description: string;
+}>;

package/src/daemon/server/handle-request-file-data.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestFileData = void 0;
+const workspace_context_1 = require("../../utils/workspace-context");
+const workspace_root_1 = require("../../utils/workspace-root");
+async function handleRequestFileData() {
+    const response = JSON.stringify((0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot));
+    return {
+        response,
+        description: 'handleRequestFileData',
+    };
+}
+exports.handleRequestFileData = handleRequestFileData;

package/src/daemon/server/handle-request-project-graph.d.ts

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

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestProjectGraph = void 0;
+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,
+        };
+    }
+}
+exports.handleRequestProjectGraph = handleRequestProjectGraph;

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

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+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,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleRequestShutdown = void 0;
+const shutdown_utils_1 = require("./shutdown-utils");
+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',
+            });
+        }, 0);
+        return {
+            description: 'Shutdown initiated',
+            response: '{}',
+        };
+    }
+}
+exports.handleRequestShutdown = handleRequestShutdown;

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,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disableOutputsTracking = exports.processFileChangesInOutputs = exports.outputsHashesMatch = exports.recordOutputsHash = exports.recordedHash = exports._outputsHashesMatch = exports._recordOutputsHash = void 0;
+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);
+        }
+    }
+}
+exports._recordOutputsHash = _recordOutputsHash;
+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;
+}
+exports._outputsHashesMatch = _outputsHashesMatch;
+function recordedHash(output) {
+    return recordedHashes[output];
+}
+exports.recordedHash = recordedHash;
+async function recordOutputsHash(_outputs, hash) {
+    const outputs = await normalizeOutputs(_outputs);
+    if (disabled)
+        return;
+    _recordOutputsHash(outputs, hash);
+}
+exports.recordOutputsHash = recordOutputsHash;
+async function outputsHashesMatch(_outputs, hash) {
+    const outputs = await normalizeOutputs(_outputs);
+    if (disabled)
+        return false;
+    return _outputsHashesMatch(outputs, hash);
+}
+exports.outputsHashesMatch = outputsHashesMatch;
+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);
+        }
+    }
+}
+exports.processFileChangesInOutputs = processFileChangesInOutputs;
+function disableOutputsTracking() {
+    disabled = true;
+}
+exports.disableOutputsTracking = disableOutputsTracking;

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

@@ -0,0 +1,22 @@
+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;
+    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 {};