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

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

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
+exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
+exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
+exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+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;
+const log = (...messageParts) => {
+    logger_1.serverLogger.log('[SYNC]:', ...messageParts);
+};
+// TODO(leo): check conflicts and reuse the Tree where possible
+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;
+        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');
+                    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();
+    }
+    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);
+    }
+    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();
+    for (const generator of registeredSyncGenerators) {
+        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;
+        }
+        const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        for (const generator of scheduledGenerators) {
+            runGenerator(generator, projects);
+        }
+        await Promise.all(syncGeneratorsCacheResultPromises.values());
+    }, waitPeriod);
+}
+async function getCachedRegisteredSyncGenerators() {
+    log('get registered sync generators');
+    if (!registeredSyncGenerators) {
+        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 [...registeredSyncGenerators];
+}
+function collectAllRegisteredSyncGenerators(projectGraph) {
+    const projectGraphHash = hashProjectGraph(projectGraph);
+    if (storedProjectGraphHash !== projectGraphHash) {
+        storedProjectGraphHash = projectGraphHash;
+        registeredTaskSyncGenerators =
+            (0, sync_generators_1.collectRegisteredTaskSyncGenerators)(projectGraph);
+    }
+    else {
+        log('project graph hash is the same, not collecting task sync generators');
+    }
+    const nxJson = (0, nx_json_1.readNxJson)();
+    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');
+    }
+    const generators = new Set([
+        ...registeredTaskSyncGenerators,
+        ...registeredGlobalSyncGenerators,
+    ]);
+    if (!registeredSyncGenerators) {
+        registeredSyncGenerators = generators;
+        return;
+    }
+    for (const generator of registeredSyncGenerators) {
+        if (!generators.has(generator)) {
+            registeredSyncGenerators.delete(generator);
+            syncGeneratorsCacheResultPromises.delete(generator);
+        }
+    }
+    for (const generator of generators) {
+        if (!registeredSyncGenerators.has(generator)) {
+            registeredSyncGenerators.add(generator);
+        }
+    }
+}
+function runGenerator(generator, projects) {
+    log('running scheduled generator', generator);
+    // remove it from the scheduled set
+    scheduledGenerators.delete(generator);
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    // run the generator and cache the result
+    syncGeneratorsCacheResultPromises.set(generator, (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+        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.js

@@ -10,6 +10,7 @@ const shutdown_utils_1 = require("./shutdown-utils");
 const path_2 = require("../../utils/path");
 const ignore_1 = require("../../utils/ignore");
 const cache_1 = require("../cache");
+const server_1 = require("./server");
 const ALWAYS_IGNORE = [
     ...(0, ignore_1.getAlwaysIgnore)(workspace_root_1.workspaceRoot),
     (0, socket_utils_1.getFullOsSocketPath)(),
@@ -28,6 +29,7 @@ async function watchWorkspace(server, cb) {
                 (0, shutdown_utils_1.handleServerProcessTermination)({
                     server,
                     reason: 'this process is no longer the current daemon (native)',
+                    sockets: server_1.openSockets,
                 });
             }
             if (event.path.endsWith('.gitignore') || event.path === '.nxignore') {
@@ -35,6 +37,7 @@ async function watchWorkspace(server, cb) {
                 (0, shutdown_utils_1.handleServerProcessTermination)({
                     server,
                     reason: 'Stopping the daemon the set of ignored files changed (native)',
+                    sockets: server_1.openSockets,
                 });
             }
         }

package/src/daemon/socket-utils.js

@@ -15,20 +15,33 @@ exports.isWindows = (0, os_1.platform)() === 'win32';
  * 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 = () => exports.isWindows
-    ? '\\\\.\\pipe\\nx\\' + (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)())
-    : (0, path_1.resolve)((0, tmp_dir_1.getDaemonSocketDir)());
+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'));
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + (0, path_1.resolve)(path) : (0, path_1.resolve)(path);
+    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'));
-    return exports.isWindows ? '\\\\.\\pipe\\nx\\' + (0, path_1.resolve)(path) : (0, path_1.resolve)(path);
+    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)());

package/src/daemon/tmp-dir.js

@@ -53,7 +53,8 @@ function socketDirName() {
  */
 function getSocketDir(alreadyUnique = false) {
     try {
-        const dir = process.env.NX_DAEMON_SOCKET_DIR ??
+        const dir = process.env.NX_SOCKET_DIR ??
+            process.env.NX_DAEMON_SOCKET_DIR ??
             (alreadyUnique ? tmp_1.tmpdir : socketDirName());
         (0, fs_extra_1.ensureDirSync)(dir);
         return dir;

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -94,7 +94,7 @@ function addNxCloudOptionsToNxJson(tree, token, directory = '') {
         });
     }
 }
-function addNxCloudIdToNxJson(tree, nxCloudId, directory = tree.root) {
+function addNxCloudIdToNxJson(tree, nxCloudId, directory = '') {
     const nxJsonPath = (0, path_1.join)(directory, 'nx.json');
     if (tree.exists(nxJsonPath)) {
         (0, json_1.updateJson)(tree, (0, path_1.join)(directory, 'nx.json'), (nxJson) => {

package/src/nx-cloud/models/onboarding-status.d.ts

@@ -0,0 +1 @@
+export type NxCloudOnBoardingStatus = 'claimed' | 'unclaimed' | 'not-configured';

package/src/nx-cloud/models/onboarding-status.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/nx-cloud/utilities/is-workspace-claimed.d.ts

@@ -0,0 +1 @@
+export declare function isWorkspaceClaimed(nxCloudAccessToken: any): Promise<any>;

package/src/nx-cloud/utilities/is-workspace-claimed.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWorkspaceClaimed = isWorkspaceClaimed;
+const get_cloud_options_1 = require("./get-cloud-options");
+async function isWorkspaceClaimed(nxCloudAccessToken) {
+    if (!nxCloudAccessToken)
+        return false;
+    const apiUrl = (0, get_cloud_options_1.getCloudUrl)();
+    try {
+        const response = await require('axios').post(`${apiUrl}/nx-cloud/is-workspace-claimed`, {
+            nxCloudAccessToken,
+        });
+        if (response.data.message) {
+            return false;
+        }
+        else {
+            return response.data;
+        }
+    }
+    catch (e) {
+        // We want to handle cases the if the request fails for any reason
+        return false;
+    }
+}

package/src/nx-cloud/utilities/onboarding.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '../../generators/tree';
+import { NxCloudOnBoardingStatus } from '../models/onboarding-status';
+export declare function createNxCloudOnboardingURLForWelcomeApp(tree: Tree, token?: string): Promise<NxCloudOnBoardingStatus>;
+export declare function getNxCloudAppOnBoardingUrl(token: string): Promise<string>;
+export declare function readNxCloudToken(tree: Tree): any;

package/src/nx-cloud/utilities/onboarding.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNxCloudOnboardingURLForWelcomeApp = createNxCloudOnboardingURLForWelcomeApp;
+exports.getNxCloudAppOnBoardingUrl = getNxCloudAppOnBoardingUrl;
+exports.readNxCloudToken = readNxCloudToken;
+const devkit_exports_1 = require("../../devkit-exports");
+const is_workspace_claimed_1 = require("./is-workspace-claimed");
+const url_shorten_1 = require("./url-shorten");
+const run_command_1 = require("../../tasks-runner/run-command");
+async function createNxCloudOnboardingURLForWelcomeApp(tree, token) {
+    token = token || readNxCloudToken(tree);
+    if (!token) {
+        return 'not-configured';
+    }
+    return (await (0, is_workspace_claimed_1.isWorkspaceClaimed)(token)) ? 'claimed' : 'unclaimed';
+}
+async function getNxCloudAppOnBoardingUrl(token) {
+    if (!token) {
+        return null;
+    }
+    const onboardingUrl = await (0, url_shorten_1.createNxCloudOnboardingURL)('nx-welcome-app', token);
+    return onboardingUrl;
+}
+function readNxCloudToken(tree) {
+    const nxJson = (0, devkit_exports_1.readNxJson)(tree);
+    const { accessToken } = (0, run_command_1.getRunnerOptions)('default', nxJson, {}, true);
+    return accessToken;
+}

package/src/project-graph/plugins/internal-api.js

@@ -13,7 +13,6 @@ const loader_1 = require("./loader");
 const utils_1 = require("./utils");
 const error_types_1 = require("../error-types");
 const native_1 = require("../../native");
-const os_1 = require("os");
 class LoadedNxPlugin {
     constructor(plugin, pluginDefinition) {
         this.name = plugin.name;
@@ -72,12 +71,24 @@ exports.LoadedNxPlugin = LoadedNxPlugin;
 // Allows loaded plugins to not be reloaded when
 // referenced multiple times.
 exports.nxPluginCache = new Map();
+function isIsolationEnabled() {
+    // Explicitly enabled, regardless of further conditions
+    if (process.env.NX_ISOLATE_PLUGINS === 'true') {
+        return true;
+    }
+    if (
+    // Explicitly disabled
+    process.env.NX_ISOLATE_PLUGINS === 'false' ||
+        // Isolation is disabled on WASM builds currently.
+        native_1.IS_WASM) {
+        return false;
+    }
+    // Default value
+    return true;
+}
 async function loadNxPlugins(plugins, root = workspace_root_1.workspaceRoot) {
     performance.mark('loadNxPlugins:start');
-    const loadingMethod = process.env.NX_ISOLATE_PLUGINS === 'true' ||
-        (!native_1.IS_WASM &&
-            (0, os_1.platform)() !== 'win32' &&
-            process.env.NX_ISOLATE_PLUGINS !== 'false')
+    const loadingMethod = isIsolationEnabled()
         ? isolation_1.loadNxPluginInIsolation
         : loader_1.loadNxPlugin;
     plugins = await normalizePlugins(plugins, root);

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -106,7 +106,11 @@ export interface PluginWorkerProcessProjectGraphResult {
         tx: string;
     };
 }
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
+export interface PluginWorkerShutdownMessage {
+    type: 'shutdown';
+    payload: {};
+}
+export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerShutdownMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage | PluginCreateMetadataMessage;
 export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult | PluginCreateMetadataResult;
 export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
 export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;

package/src/project-graph/plugins/isolation/messaging.js

@@ -14,6 +14,7 @@ function isPluginWorkerMessage(message) {
             'createDependencies',
             'processProjectGraph',
             'createMetadata',
+            'shutdown',
         ].includes(message.type));
 }
 function isPluginWorkerResult(message) {

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -29,8 +29,8 @@ async function loadRemoteNxPlugin(plugin, root) {
     const exitHandler = createWorkerExitHandler(worker, pendingPromises);
     const cleanupFunction = () => {
         worker.off('exit', exitHandler);
+        shutdownPluginWorker(socket);
         socket.destroy();
-        shutdownPluginWorker(worker);
         nxPluginWorkerCache.delete(cacheKey);
     };
     cleanupFunctions.add(cleanupFunction);
@@ -55,11 +55,8 @@ async function loadRemoteNxPlugin(plugin, root) {
     nxPluginWorkerCache.set(cacheKey, pluginPromise);
     return [pluginPromise, cleanupFunction];
 }
-function shutdownPluginWorker(worker) {
-    // Clears the plugin cache so no refs to the workers are held
-    internal_api_1.nxPluginCache.clear();
-    // logger.verbose(`[plugin-pool] starting worker shutdown`);
-    worker.kill('SIGINT');
+function shutdownPluginWorker(socket) {
+    (0, messaging_1.sendMessageOverSocket)(socket, { type: 'shutdown', payload: {} });
 }
 /**
  * Creates a message handler for the given worker.
@@ -200,6 +197,7 @@ function createWorkerExitHandler(worker, pendingPromises) {
 }
 let cleanedUp = false;
 const exitHandler = () => {
+    internal_api_1.nxPluginCache.clear();
     for (const fn of cleanupFunctions) {
         fn();
     }

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -49,6 +49,21 @@ const server = (0, net_1.createServer)((socket) => {
                     };
                 }
             },
+            shutdown: async () => {
+                // Stops accepting new connections, but existing connections are
+                // not closed immediately.
+                server.close(() => {
+                    try {
+                        (0, fs_1.unlinkSync)(socketPath);
+                    }
+                    catch (e) { }
+                    process.exit(0);
+                });
+                // Closes existing connection.
+                socket.end();
+                // Destroys the socket once it's fully closed.
+                socket.destroySoon();
+            },
             createNodes: async ({ configFiles, context, tx }) => {
                 try {
                     const result = await plugin.createNodes[1](configFiles, context);

package/src/project-graph/utils/project-configuration-utils.js

@@ -446,7 +446,7 @@ function normalizeTargets(project, sourceMaps, nxJsonConfiguration) {
         project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
         const projectSourceMaps = sourceMaps[project.root];
         const targetConfig = project.targets[targetName];
-        const targetDefaults = readTargetDefaultsForTarget(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor);
+        const targetDefaults = deepClone(readTargetDefaultsForTarget(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor));
         // We only apply defaults if they exist
         if (targetDefaults && isCompatibleTarget(targetConfig, targetDefaults)) {
             project.targets[targetName] = mergeTargetDefaultWithTargetDefinition(targetName, project, normalizeTarget(targetDefaults, project), projectSourceMaps);
@@ -499,9 +499,12 @@ function targetDefaultShouldBeApplied(key, sourceMap) {
     const [, plugin] = sourceInfo;
     return !plugin?.startsWith('nx/');
 }
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
 function mergeTargetDefaultWithTargetDefinition(targetName, project, targetDefault, sourceMap) {
     const targetDefinition = project.targets[targetName] ?? {};
-    const result = JSON.parse(JSON.stringify(targetDefinition));
+    const result = deepClone(targetDefinition);
     for (const key in targetDefault) {
         switch (key) {
             case 'options': {

package/src/tasks-runner/run-command.d.ts

@@ -5,7 +5,7 @@ import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
 import { LifeCycle } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
-export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], projectGraph: ProjectGraph, { nxJson }: {
+export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;