@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,15 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import { type FlushSyncGeneratorChangesResult, type SyncGeneratorRunResult } from '../../utils/sync-generators';
+export declare function clearSyncGeneratorsCache(): void;
+export declare function getCachedSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorRunResult[]>;
+export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<FlushSyncGeneratorChangesResult>;
+export declare function collectAndScheduleSyncGenerators(projectGraph: ProjectGraph): void;
+export declare function getCachedRegisteredSyncGenerators(): Promise<{
+    globalGenerators: string[];
+    taskGenerators: string[];
+}>;
+/**
+ * @internal
+ */
+export declare function _getConflictingGeneratorGroups(results: SyncGeneratorRunResult[]): string[][];
+//# sourceMappingURL=sync-generators.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sync-generators.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/sync-generators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAK/D,OAAO,EAKL,KAAK,+BAA+B,EACpC,KAAK,sBAAsB,EAE5B,MAAM,6BAA6B,CAAC;AA0BrC,wBAAgB,wBAAwB,IAAI,IAAI,CAG/C;AAED,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,sBAAsB,EAAE,CAAC,CA8BnC;AAED,wBAAsB,+BAA+B,CACnD,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,+BAA+B,CAAC,CAU1C;AAED,wBAAgB,gCAAgC,CAC9C,YAAY,EAAE,YAAY,GACzB,IAAI,CAoEN;AAED,wBAAsB,iCAAiC,IAAI,OAAO,CAAC;IACjE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC,CAcD;AAsKD;;GAEG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,sBAAsB,EAAE,GAChC,MAAM,EAAE,EAAE,CA8CZ"}

package/src/daemon/server/sync-generators.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearSyncGeneratorsCache = clearSyncGeneratorsCache;
+exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
+exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
+exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
+exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+exports._getConflictingGeneratorGroups = _getConflictingGeneratorGroups;
+const nx_json_1 = require("../../config/nx-json");
+const tree_1 = require("../../generators/tree");
+const file_hasher_1 = require("../../hasher/file-hasher");
+const project_graph_1 = require("../../project-graph/project-graph");
+const sync_generators_1 = require("../../utils/sync-generators");
+const workspace_root_1 = require("../../utils/workspace-root");
+const logger_1 = require("../logger");
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+const syncGeneratorsCacheResultPromises = new Map();
+let registeredTaskSyncGenerators = new Set();
+let registeredGlobalSyncGenerators = new Set();
+const scheduledGenerators = new Set();
+let waitPeriod = 100;
+let registeredSyncGenerators;
+let scheduledTimeoutId;
+let storedProjectGraphHash;
+let storedNxJsonHash;
+let storedDisabledTaskSyncGeneratorsHash;
+const log = (...messageParts) => {
+    logger_1.serverLogger.log('[SYNC]:', ...messageParts);
+};
+function clearSyncGeneratorsCache() {
+    log('clearing sync generators cache due to file changes');
+    syncGeneratorsCacheResultPromises.clear();
+}
+async function getCachedSyncGeneratorChanges(generators) {
+    try {
+        log('get sync generators changes on demand', generators);
+        // this is invoked imperatively, so we clear any scheduled run
+        if (scheduledTimeoutId) {
+            log('clearing scheduled run');
+            clearTimeout(scheduledTimeoutId);
+            scheduledTimeoutId = undefined;
+        }
+        // reset the wait time
+        waitPeriod = 100;
+        const results = await getFromCacheOrRunGenerators(generators);
+        const conflicts = _getConflictingGeneratorGroups(results);
+        if (!conflicts.length) {
+            // there are no conflicts
+            return results;
+        }
+        // there are conflicts, so we need to re-run the conflicting generators
+        // using the same tree
+        return await processConflictingGenerators(conflicts, results);
+    }
+    catch (e) {
+        console.error(e);
+        syncGeneratorsCacheResultPromises.clear();
+        return [];
+    }
+}
+async function flushSyncGeneratorChangesToDisk(generators) {
+    log('flush sync generators changes', generators);
+    const results = await getCachedSyncGeneratorChanges(generators);
+    for (const generator of generators) {
+        syncGeneratorsCacheResultPromises.delete(generator);
+    }
+    return await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+}
+function collectAndScheduleSyncGenerators(projectGraph) {
+    if (!projectGraph) {
+        // If the project graph is not available, we can't collect and schedule
+        // sync generators. The project graph error will be reported separately.
+        return;
+    }
+    log('collect registered sync generators');
+    collectAllRegisteredSyncGenerators(projectGraph);
+    // a change imply we need to re-run all the generators
+    // make sure to schedule all the collected generators
+    scheduledGenerators.clear();
+    if (!registeredSyncGenerators.globalGenerators.size &&
+        !registeredSyncGenerators.taskGenerators.size) {
+        // there are no generators to run
+        return;
+    }
+    const uniqueSyncGenerators = new Set([
+        ...registeredSyncGenerators.globalGenerators,
+        ...registeredSyncGenerators.taskGenerators,
+    ]);
+    for (const generator of uniqueSyncGenerators) {
+        scheduledGenerators.add(generator);
+    }
+    log('scheduling:', [...scheduledGenerators]);
+    if (scheduledTimeoutId) {
+        // we have a scheduled run already, so we don't need to do anything
+        return;
+    }
+    scheduledTimeoutId = setTimeout(async () => {
+        scheduledTimeoutId = undefined;
+        if (waitPeriod < 4000) {
+            waitPeriod = waitPeriod * 2;
+        }
+        if (scheduledGenerators.size === 0) {
+            // no generators to run
+            return;
+        }
+        // Fetch the latest graph instead of using the captured one which might be stale
+        const { projectGraph: latestGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        if (!latestGraph || error) {
+            log('Cannot run scheduled generators: graph unavailable or errored');
+            return;
+        }
+        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(latestGraph);
+        for (const generator of scheduledGenerators) {
+            syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
+        }
+        await Promise.all(syncGeneratorsCacheResultPromises.values());
+    }, waitPeriod);
+}
+async function getCachedRegisteredSyncGenerators() {
+    log('get registered sync generators');
+    if (!registeredGlobalSyncGenerators && !registeredTaskSyncGenerators) {
+        log('no registered sync generators, collecting them');
+        const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        collectAllRegisteredSyncGenerators(projectGraph);
+    }
+    else {
+        log('registered sync generators already collected, returning them');
+    }
+    return {
+        globalGenerators: [...registeredGlobalSyncGenerators],
+        taskGenerators: [...registeredTaskSyncGenerators],
+    };
+}
+async function getFromCacheOrRunGenerators(generators) {
+    let projects;
+    let errored = false;
+    const getProjectsConfigurations = async () => {
+        if (projects || errored) {
+            return projects;
+        }
+        const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        projects = projectGraph
+            ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+            : null;
+        errored = error !== undefined;
+        return projects;
+    };
+    return (await Promise.all(generators.map(async (generator) => {
+        if (scheduledGenerators.has(generator) ||
+            !syncGeneratorsCacheResultPromises.has(generator)) {
+            // it's scheduled to run (there are pending changes to process) or
+            // it's not scheduled and there's no cached result, so run it
+            const projects = await getProjectsConfigurations();
+            if (projects) {
+                log(generator, 'already scheduled or not cached, running it now');
+                syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
+            }
+            else {
+                log(generator, 'already scheduled or not cached, project graph errored');
+                /**
+                 * This should never happen. This is invoked imperatively, and by
+                 * the time it is invoked, the project graph would have already
+                 * been requested. If it errored, it would have been reported and
+                 * this wouldn't have been invoked. We handle it just in case.
+                 *
+                 * Since the project graph would be reported by the relevant
+                 * handlers separately, we just ignore the error, don't cache
+                 * any result and return an empty result, the next time this is
+                 * invoked the process will repeat until it eventually recovers
+                 * when the project graph is fixed.
+                 */
+                return Promise.resolve({ changes: [], generatorName: generator });
+            }
+        }
+        else {
+            log(generator, 'not scheduled and has cached result, returning cached result');
+        }
+        return syncGeneratorsCacheResultPromises.get(generator);
+    }))).flat();
+}
+async function runConflictingGenerators(tree, generators) {
+    const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const projects = projectGraph
+        ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+        : null;
+    if (!projects) {
+        /**
+         * This should never happen. This is invoked imperatively, and by
+         * the time it is invoked, the project graph would have already
+         * been requested. If it errored, it would have been reported and
+         * this wouldn't have been invoked. We handle it just in case.
+         *
+         * Since the project graph would be reported by the relevant
+         * handlers separately, we just ignore the error.
+         */
+        return generators.map((generator) => ({
+            changes: [],
+            generatorName: generator,
+        }));
+    }
+    // we need to run conflicting generators sequentially because they use the same tree
+    const results = [];
+    for (const generator of generators) {
+        log(generator, 'running it now');
+        results.push(await runGenerator(generator, projects, tree));
+    }
+    return results;
+}
+async function processConflictingGenerators(conflicts, initialResults) {
+    const conflictRunResults = (await Promise.all(conflicts.map((generators) => {
+        const [firstGenerator, ...generatorsToRun] = generators;
+        // it must exists because the conflicts were identified from the initial results
+        // and it's guaranteed to be a success result
+        const firstGeneratorResult = initialResults.find((r) => r.generatorName === firstGenerator);
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generators ${generators.join(',')}`);
+        // pre-apply the changes from the first generator to avoid running it
+        for (const change of firstGeneratorResult.changes) {
+            if (change.type === 'CREATE' || change.type === 'UPDATE') {
+                tree.write(change.path, change.content, change.options);
+            }
+            else if (change.type === 'DELETE') {
+                tree.delete(change.path);
+            }
+        }
+        /**
+         * We don't cache the results of conflicting generators because they
+         * use the same tree, so some files might contain results from multiple
+         * generators and we don't have guarantees that the same combination of
+         * generators will run together.
+         */
+        return runConflictingGenerators(tree, generatorsToRun);
+    }))).flat();
+    /**
+     * The order of the results from the re-run generators is important because
+     * the last result from a group of conflicting generators will contain the
+     * changes from the previous conflicting generators. So, instead of replacing
+     * in-place the initial results, we first add the results from the re-run
+     * generators, and then add the initial results that were not from a
+     * conflicting generator.
+     */
+    const results = [...conflictRunResults];
+    for (const result of initialResults) {
+        if (conflictRunResults.every((r) => r.generatorName !== result.generatorName)) {
+            // this result is not from a conflicting generator, so we add it to the
+            // results
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * @internal
+ */
+function _getConflictingGeneratorGroups(results) {
+    const changedFileToGeneratorMap = new Map();
+    for (const result of results) {
+        if ('error' in result) {
+            continue;
+        }
+        for (const change of result.changes) {
+            if (!changedFileToGeneratorMap.has(change.path)) {
+                changedFileToGeneratorMap.set(change.path, new Set());
+            }
+            changedFileToGeneratorMap.get(change.path).add(result.generatorName);
+        }
+    }
+    const conflicts = [];
+    for (const generatorSet of changedFileToGeneratorMap.values()) {
+        if (generatorSet.size === 1) {
+            // no conflicts
+            continue;
+        }
+        if (conflicts.length === 0) {
+            // there are no conflicts yet, so we just add the first group
+            conflicts.push(new Set(generatorSet));
+            continue;
+        }
+        // identify if any of the current generator sets intersect with any of the
+        // existing conflict groups
+        const generatorsArray = Array.from(generatorSet);
+        const existingConflictGroup = conflicts.find((group) => generatorsArray.some((generator) => group.has(generator)));
+        if (existingConflictGroup) {
+            // there's an intersecting group, so we merge the two
+            for (const generator of generatorsArray) {
+                existingConflictGroup.add(generator);
+            }
+        }
+        else {
+            // there's no intersecting group, so we create a new one
+            conflicts.push(new Set(generatorsArray));
+        }
+    }
+    return conflicts.map((group) => Array.from(group));
+}
+function collectAllRegisteredSyncGenerators(projectGraph) {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const projectGraphHash = hashProjectGraph(projectGraph);
+    const disabledTaskSyncGeneratorsHash = (0, file_hasher_1.hashArray)(nxJson.sync?.disabledTaskSyncGenerators?.sort() ?? []);
+    if (projectGraphHash !== storedProjectGraphHash ||
+        disabledTaskSyncGeneratorsHash !== storedDisabledTaskSyncGeneratorsHash) {
+        storedProjectGraphHash = projectGraphHash;
+        storedDisabledTaskSyncGeneratorsHash = disabledTaskSyncGeneratorsHash;
+        registeredTaskSyncGenerators =
+            (0, sync_generators_1.collectEnabledTaskSyncGeneratorsFromProjectGraph)(projectGraph, nxJson);
+    }
+    else {
+        log('project graph hash is the same, not collecting task sync generators');
+    }
+    const nxJsonHash = (0, file_hasher_1.hashArray)(nxJson.sync?.globalGenerators?.sort() ?? []);
+    if (storedNxJsonHash !== nxJsonHash) {
+        storedNxJsonHash = nxJsonHash;
+        registeredGlobalSyncGenerators =
+            (0, sync_generators_1.collectRegisteredGlobalSyncGenerators)(nxJson);
+    }
+    else {
+        log('nx.json hash is the same, not collecting global sync generators');
+    }
+    if (!registeredSyncGenerators) {
+        registeredSyncGenerators = {
+            globalGenerators: registeredGlobalSyncGenerators,
+            taskGenerators: registeredTaskSyncGenerators,
+        };
+        return;
+    }
+    for (const generator of registeredSyncGenerators.globalGenerators) {
+        if (!registeredGlobalSyncGenerators.has(generator)) {
+            registeredSyncGenerators.globalGenerators.delete(generator);
+            syncGeneratorsCacheResultPromises.delete(generator);
+        }
+    }
+    for (const generator of registeredSyncGenerators.taskGenerators) {
+        if (!registeredTaskSyncGenerators.has(generator)) {
+            registeredSyncGenerators.taskGenerators.delete(generator);
+            syncGeneratorsCacheResultPromises.delete(generator);
+        }
+    }
+    for (const generator of registeredGlobalSyncGenerators) {
+        if (!registeredSyncGenerators.globalGenerators.has(generator)) {
+            registeredSyncGenerators.globalGenerators.add(generator);
+        }
+    }
+    for (const generator of registeredTaskSyncGenerators) {
+        if (!registeredSyncGenerators.taskGenerators.has(generator)) {
+            registeredSyncGenerators.taskGenerators.add(generator);
+        }
+    }
+}
+function runGenerator(generator, projects, tree) {
+    log('running scheduled generator', generator);
+    // remove it from the scheduled set
+    scheduledGenerators.delete(generator);
+    tree ??= new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    return (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+        if ('error' in result) {
+            log(generator, 'error:', result.error.message);
+        }
+        else {
+            log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
+        }
+        return result;
+    });
+}
+function hashProjectGraph(projectGraph) {
+    const stringifiedProjects = Object.entries(projectGraph.nodes)
+        .sort(([projectNameA], [projectNameB]) => projectNameA.localeCompare(projectNameB))
+        .map(([projectName, projectConfig]) => `${projectName}:${JSON.stringify(projectConfig)}`);
+    return (0, file_hasher_1.hashArray)(stringifiedProjects);
+}

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

@@ -0,0 +1,12 @@
+import { Server } from 'net';
+import type { WatchEvent } from '../../native';
+export type FileWatcherCallback = (err: Error | string | null, changeEvents: WatchEvent[] | null) => Promise<void>;
+export declare function watchWorkspace(server: Server, cb: FileWatcherCallback): Promise<import("../../native").Watcher>;
+export declare function watchOutputFiles(server: Server, cb: FileWatcherCallback): Promise<import("../../native").Watcher>;
+/**
+ * NOTE: An event type of "create" will also apply to the case where the user has restored
+ * an original version of a file after modifying/deleting it by using git, so we adjust
+ * our log language accordingly.
+ */
+export declare function convertChangeEventsToLogMessage(changeEvents: WatchEvent[]): string;
+//# sourceMappingURL=watcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"watcher.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/daemon/server/watcher.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,KAAK,CAAC;AAG7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/C,MAAM,MAAM,mBAAmB,GAAG,CAChC,GAAG,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,EAC1B,YAAY,EAAE,UAAU,EAAE,GAAG,IAAI,KAC9B,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,mBAAmB,2CAyB3E;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,mBAAmB,2CAmCxB;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,YAAY,EAAE,UAAU,EAAE,GACzB,MAAM,CAqCR"}

package/src/daemon/server/watcher.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchWorkspace = watchWorkspace;
+exports.watchOutputFiles = watchOutputFiles;
+exports.convertChangeEventsToLogMessage = convertChangeEventsToLogMessage;
+const workspace_root_1 = require("../../utils/workspace-root");
+const path_1 = require("path");
+const shutdown_utils_1 = require("./shutdown-utils");
+const path_2 = require("../../utils/path");
+const cache_1 = require("../cache");
+const server_1 = require("./server");
+async function watchWorkspace(server, cb) {
+    const { Watcher } = await Promise.resolve().then(() => require('../../native'));
+    const watcher = new Watcher(workspace_root_1.workspaceRoot);
+    watcher.watch((err, events) => {
+        if (err) {
+            return cb(err, null);
+        }
+        for (const event of events) {
+            if (event.path.endsWith('.gitignore') || event.path === '.nxignore') {
+                // If the ignore files themselves have changed we need to dynamically update our cached ignoreGlobs
+                (0, shutdown_utils_1.handleServerProcessTermination)({
+                    server,
+                    reason: 'Stopping the daemon the set of ignored files changed (native)',
+                    sockets: server_1.openSockets,
+                });
+            }
+        }
+        cb(null, events);
+    });
+    return watcher;
+}
+async function watchOutputFiles(server, cb) {
+    const { Watcher } = await Promise.resolve().then(() => require('../../native'));
+    const relativeServerProcess = (0, path_2.normalizePath)((0, path_1.relative)(workspace_root_1.workspaceRoot, cache_1.serverProcessJsonPath));
+    const watcher = new Watcher(workspace_root_1.workspaceRoot, [`!${relativeServerProcess}`], false);
+    watcher.watch((err, events) => {
+        if (err) {
+            return cb(err, null);
+        }
+        for (const event of events) {
+            if (event.path == relativeServerProcess &&
+                (0, cache_1.getDaemonProcessIdSync)() !== process.pid) {
+                return (0, shutdown_utils_1.handleServerProcessTermination)({
+                    server,
+                    reason: 'this process is no longer the current daemon (native)',
+                    sockets: server_1.openSockets,
+                });
+            }
+        }
+        if (events.length !== 0) {
+            cb(null, events);
+        }
+    });
+    return watcher;
+}
+/**
+ * NOTE: An event type of "create" will also apply to the case where the user has restored
+ * an original version of a file after modifying/deleting it by using git, so we adjust
+ * our log language accordingly.
+ */
+function convertChangeEventsToLogMessage(changeEvents) {
+    // If only a single file was changed, show the information inline
+    if (changeEvents.length === 1) {
+        const { path, type } = changeEvents[0];
+        let typeLog = 'updated';
+        switch (type) {
+            case 'create':
+                typeLog = 'created or restored';
+                break;
+            case 'update':
+                typeLog = 'modified';
+                break;
+            case 'delete':
+                typeLog = 'deleted';
+                break;
+        }
+        return `${path} was ${typeLog}`;
+    }
+    let numCreatedOrRestoredFiles = 0;
+    let numModifiedFiles = 0;
+    let numDeletedFiles = 0;
+    for (const event of changeEvents) {
+        switch (event.type) {
+            case 'create':
+                numCreatedOrRestoredFiles++;
+                break;
+            case 'update':
+                numModifiedFiles++;
+                break;
+            case 'delete':
+                numDeletedFiles++;
+                break;
+        }
+    }
+    return `${numCreatedOrRestoredFiles} file(s) created or restored, ${numModifiedFiles} file(s) modified, ${numDeletedFiles} file(s) deleted`;
+}

package/src/daemon/socket-utils.d.ts

@@ -0,0 +1,24 @@
+export declare const isWindows: boolean;
+/**
+ * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
+ *
+ * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections for a full breakdown
+ * of OS differences between Unix domain sockets and named pipes.
+ */
+export declare const getFullOsSocketPath: () => string;
+export declare const getForkedProcessOsSocketPath: (id: string) => string;
+export declare const getPluginOsSocketPath: (id: string) => string;
+export declare function killSocketOrPath(): void;
+export declare function serializeResult(error: Error | null, serializedProjectGraph: string | null, serializedSourceMaps: string | null): string | null;
+/**
+ * Helper to serialize data either using v8 serialization or JSON serialization, based on
+ * the user's preference and the success of each method. Should only be used by "client" side
+ * connections, daemon or other servers should respond based on the type of serialization used
+ * by the client it is communicating with.
+ *
+ * @param data Data to serialize
+ * @param force Forces one serialization method over the other
+ * @returns Serialized data as a string
+ */
+export declare function serialize(data: any, force?: 'v8' | 'json'): string;
+//# sourceMappingURL=socket-utils.d.ts.map

package/src/daemon/socket-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/daemon/socket-utils.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,SAAS,SAAyB,CAAC;AAEhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,cAM/B,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,IAAI,MAAM,WAMtD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,IAAI,MAAM,WAM/C,CAAC;AAgBF,wBAAgB,gBAAgB,IAAI,IAAI,CAIvC;AAGD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,GAAG,IAAI,EACnB,sBAAsB,EAAE,MAAM,GAAG,IAAI,EACrC,oBAAoB,EAAE,MAAM,GAAG,IAAI,GAClC,MAAM,GAAG,IAAI,CAKf;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,IAAI,GAAG,MAAM,GAAG,MAAM,CA4BlE"}

package/src/daemon/socket-utils.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginOsSocketPath = exports.getForkedProcessOsSocketPath = exports.getFullOsSocketPath = exports.isWindows = void 0;
+exports.killSocketOrPath = killSocketOrPath;
+exports.serializeResult = serializeResult;
+exports.serialize = serialize;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const tmp_dir_1 = require("./tmp-dir");
+const serializable_error_1 = require("../utils/serializable-error");
+const is_v8_serializer_enabled_1 = require("./is-v8-serializer-enabled");
+const v8_1 = require("v8");
+exports.isWindows = (0, os_1.platform)() === 'win32';
+/**
+ * For IPC with the daemon server we use unix sockets or windows named pipes, depending on the user's operating system.
+ *
+ * See https://nodejs.org/dist/latest-v14.x/docs/api/net.html#net_identifying_paths_for_ipc_connections for a full breakdown
+ * of OS differences between Unix domain sockets and named pipes.
+ */
+const getFullOsSocketPath = () => {
+    const path = (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)());
+    assertValidSocketPath(path);
+    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
+};
+exports.getFullOsSocketPath = getFullOsSocketPath;
+const getForkedProcessOsSocketPath = (id) => {
+    let path = (0, path_1.resolve)((0, path_1.join)((0, tmp_dir_1.getSocketDir)(), 'fp' + id + '.sock'));
+    assertValidSocketPath(path);
+    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
+};
+exports.getForkedProcessOsSocketPath = getForkedProcessOsSocketPath;
+const getPluginOsSocketPath = (id) => {
+    let path = (0, path_1.resolve)((0, path_1.join)((0, tmp_dir_1.getSocketDir)(true), 'plugin' + id + '.sock'));
+    assertValidSocketPath(path);
+    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + path : path;
+};
+exports.getPluginOsSocketPath = getPluginOsSocketPath;
+function assertValidSocketPath(path) {
+    if (path.length > 95) {
+        throw new Error([
+            'Attempted to open socket that exceeds the maximum socket length.',
+            '',
+            `Set NX_SOCKET_DIR to a shorter path (e.g. ${exports.isWindows ? '%TMP%/nx-tmp' : '/tmp/nx-tmp'}) to avoid this issue.`,
+        ].join('\n'));
+    }
+}
+function killSocketOrPath() {
+    try {
+        (0, fs_1.unlinkSync)((0, exports.getFullOsSocketPath)());
+    }
+    catch { }
+}
+// Prepare a serialized project graph result for sending over IPC from the server to the client
+function serializeResult(error, serializedProjectGraph, serializedSourceMaps) {
+    // We do not want to repeat work `JSON.stringify`ing an object containing the potentially large project graph so merge as strings
+    return `{ "error": ${JSON.stringify(error ? (0, serializable_error_1.createSerializableError)(error) : error)}, "projectGraph": ${serializedProjectGraph}, "sourceMaps": ${serializedSourceMaps} }`;
+}
+/**
+ * Helper to serialize data either using v8 serialization or JSON serialization, based on
+ * the user's preference and the success of each method. Should only be used by "client" side
+ * connections, daemon or other servers should respond based on the type of serialization used
+ * by the client it is communicating with.
+ *
+ * @param data Data to serialize
+ * @param force Forces one serialization method over the other
+ * @returns Serialized data as a string
+ */
+function serialize(data, force) {
+    if (force === 'v8' || (0, is_v8_serializer_enabled_1.isV8SerializerEnabled)()) {
+        try {
+            return (0, v8_1.serialize)(data).toString('binary');
+        }
+        catch (e) {
+            if (force !== 'v8') {
+                console.warn(`Data could not be serialized using v8 serialization: ${e}. Falling back to JSON serialization.`);
+                // Fall back to JSON serialization
+                return JSON.stringify(data);
+            }
+            throw e;
+        }
+    }
+    else {
+        try {
+            return JSON.stringify(data);
+        }
+        catch (e) {
+            if (force !== 'json') {
+                // Fall back to v8 serialization
+                console.warn(`Data could not be serialized using JSON.stringify: ${e}. Falling back to v8 serialization.`);
+                return (0, v8_1.serialize)(data).toString('binary');
+            }
+            throw e;
+        }
+    }
+}

package/src/daemon/tmp-dir.d.ts

@@ -0,0 +1,13 @@
+export declare const DAEMON_DIR_FOR_CURRENT_WORKSPACE: string;
+export declare const DAEMON_OUTPUT_LOG_FILE: string;
+export declare const getDaemonSocketDir: () => string;
+export declare function writeDaemonLogs(error?: string): string;
+export declare function markDaemonAsDisabled(reason: string): void;
+export declare function isDaemonDisabled(): boolean;
+/**
+ * We try to create a socket file in a tmp dir, but if it doesn't work because
+ * for instance we don't have permissions, we create it in DAEMON_DIR_FOR_CURRENT_WORKSPACE
+ */
+export declare function getSocketDir(alreadyUnique?: boolean): string;
+export declare function removeSocketDir(): void;
+//# sourceMappingURL=tmp-dir.d.ts.map

package/src/daemon/tmp-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tmp-dir.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/daemon/tmp-dir.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,gCAAgC,QAG5C,CAAC;AAEF,eAAO,MAAM,sBAAsB,QAGlC,CAAC;AAEF,eAAO,MAAM,kBAAkB,cAK5B,CAAC;AAEJ,wBAAgB,eAAe,CAAC,KAAK,CAAC,EAAE,MAAM,UAI7C;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,QAElD;AAED,wBAAgB,gBAAgB,YAO/B;AAUD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,aAAa,UAAQ,UAYjD;AAED,wBAAgB,eAAe,SAI9B"}