nx 19.6.0-beta.1 → 19.6.0-beta.2

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/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/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;

package/src/tasks-runner/run-command.js

@@ -4,16 +4,20 @@ exports.runCommand = runCommand;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
+const enquirer_1 = require("enquirer");
+const ora = require("ora");
 const path_1 = require("path");
 const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
+const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
 const is_ci_1 = require("../utils/is-ci");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
+const sync_generators_1 = require("../utils/sync-generators");
 const workspace_root_1 = require("../utils/workspace-root");
 const create_task_graph_1 = require("./create-task-graph");
 const life_cycle_1 = require("./life-cycle");
@@ -27,6 +31,7 @@ const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-c
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
+const chalk = require("chalk");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -90,10 +95,10 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
     }
     return taskGraph;
 }
-async function runCommand(projectsToRun, projectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, params_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
         const projectNames = projectsToRun.map((t) => t.name);
-        const taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+        const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
         const tasks = Object.values(taskGraph.tasks);
         const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
         const status = await invokeTasksRunner({
@@ -111,6 +116,119 @@ async function runCommand(projectsToRun, projectGraph, { nxJson }, nxArgs, overr
     });
     return status;
 }
+async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
+    let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+    if (process.env.NX_ENABLE_SYNC_GENERATORS !== 'true') {
+        return { projectGraph, taskGraph };
+    }
+    // collect unique syncGenerators from the tasks
+    const uniqueSyncGenerators = new Set();
+    for (const { target } of Object.values(taskGraph.tasks)) {
+        const { syncGenerators } = projectGraph.nodes[target.project].data.targets[target.target];
+        if (!syncGenerators) {
+            continue;
+        }
+        for (const generator of syncGenerators) {
+            uniqueSyncGenerators.add(generator);
+        }
+    }
+    if (!uniqueSyncGenerators.size) {
+        // There are no sync generators registered in the tasks to run
+        return { projectGraph, taskGraph };
+    }
+    const syncGenerators = Array.from(uniqueSyncGenerators);
+    const results = await (0, sync_generators_1.getSyncGeneratorChanges)(syncGenerators);
+    if (!results.length) {
+        // There are no changes to sync, workspace is up to date
+        return { projectGraph, taskGraph };
+    }
+    const outOfSyncTitle = 'The workspace is out of sync';
+    const resultBodyLines = (0, sync_generators_1.syncGeneratorResultsToMessageLines)(results);
+    const fixMessage = 'You can manually run `nx sync` to update your workspace or you can set `sync.applyChanges` to `true` in your `nx.json` to apply the changes automatically when running tasks.';
+    const willErrorOnCiMessage = 'Please note that this will be an error on CI.';
+    if ((0, is_ci_1.isCI)() || !process.stdout.isTTY) {
+        // If the user is running in CI or is running in a non-TTY environment we
+        // throw an error to stop the execution of the tasks.
+        throw new Error(`${outOfSyncTitle}\n${resultBodyLines.join('\n')}\n${fixMessage}`);
+    }
+    if (nxJson.sync?.applyChanges === false) {
+        // If the user has set `sync.applyChanges` to `false` in their `nx.json`
+        // we don't prompt the them and just log a warning informing them that
+        // the workspace is out of sync and they have it set to not apply changes
+        // automatically.
+        output_1.output.warn({
+            title: outOfSyncTitle,
+            bodyLines: [
+                ...resultBodyLines,
+                'Your workspace is set to not apply changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
+                willErrorOnCiMessage,
+                fixMessage,
+            ],
+        });
+        return { projectGraph, taskGraph };
+    }
+    output_1.output.warn({
+        title: outOfSyncTitle,
+        bodyLines: [
+            ...resultBodyLines,
+            nxJson.sync?.applyChanges === true
+                ? 'Proceeding to sync the changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
+                : willErrorOnCiMessage,
+        ],
+    });
+    const applyChanges = nxJson.sync?.applyChanges === true ||
+        (await promptForApplyingSyncGeneratorChanges());
+    if (applyChanges) {
+        const spinner = ora('Syncing the workspace...');
+        spinner.start();
+        // Flush sync generator changes to disk
+        await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+        // Re-create project graph and task graph
+        projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+        taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
+        if (nxJson.sync?.applyChanges === true) {
+            spinner.succeed(`The workspace was synced successfully!
+
+Please make sure to commit the changes to your repository or this will error on CI.`);
+        }
+        else {
+            // The user was prompted and we already logged a message about erroring on CI
+            // so here we just tell them to commit the changes.
+            spinner.succeed(`The workspace was synced successfully!
+
+Please make sure to commit the changes to your repository.`);
+        }
+    }
+    else {
+        output_1.output.warn({
+            title: 'Syncing the workspace was skipped',
+            bodyLines: [
+                'This could lead to unexpected results or errors when running tasks.',
+                fixMessage,
+            ],
+        });
+    }
+    return { projectGraph, taskGraph };
+}
+async function promptForApplyingSyncGeneratorChanges() {
+    const promptConfig = {
+        name: 'applyChanges',
+        type: 'select',
+        message: 'Would you like to sync the changes to get your worskpace up to date?',
+        choices: [
+            {
+                name: 'yes',
+                message: 'Yes, sync the changes and run the tasks',
+            },
+            {
+                name: 'no',
+                message: 'No, run the tasks without syncing the changes',
+            },
+        ],
+        footer: () => chalk.dim('\nYou can skip this prompt by setting the `sync.applyChanges` option in your `nx.json`.'),
+    };
+    return await (0, enquirer_1.prompt)([promptConfig]).then(({ applyChanges }) => applyChanges === 'yes');
+}
 function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
     if (nxArgs.outputStyle == 'stream' ||
         process.env.NX_BATCH_MODE === 'true' ||

package/src/utils/plugins/output.js

@@ -27,7 +27,7 @@ function listPlugins(plugins, title) {
         if (p.projectInference) {
             capabilities.push('project-inference');
         }
-        bodyLines.push(`${chalk.bold(p.name)} (${capabilities.join()})`);
+        bodyLines.push(`${chalk.bold(p.name)} ${capabilities.length >= 1 ? `(${capabilities.join()})` : ''}`);
     }
     output_1.output.log({
         title: title,

package/src/utils/sync-generators.d.ts

@@ -0,0 +1,22 @@
+import type { GeneratorCallback } from '../config/misc-interfaces';
+import type { ProjectGraph } from '../config/project-graph';
+import type { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { FsTree, type FileChange, type Tree } from '../generators/tree';
+export type SyncGeneratorResult = void | {
+    callback?: GeneratorCallback;
+    outOfSyncMessage?: string;
+};
+export type SyncGenerator = (tree: Tree) => SyncGeneratorResult | Promise<SyncGeneratorResult>;
+export type SyncGeneratorChangesResult = {
+    changes: FileChange[];
+    generatorName: string;
+    callback?: GeneratorCallback;
+    outOfSyncMessage?: string;
+};
+export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
+export declare function flushSyncGeneratorChanges(results: SyncGeneratorChangesResult[]): Promise<void>;
+export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph): Promise<string[]>;
+export declare function runSyncGenerator(tree: FsTree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
+export declare function collectRegisteredTaskSyncGenerators(projectGraph: ProjectGraph): Set<string>;
+export declare function collectRegisteredGlobalSyncGenerators(nxJson?: import("../config/nx-json").NxJsonConfiguration<string[] | "*">): Set<string>;
+export declare function syncGeneratorResultsToMessageLines(results: SyncGeneratorChangesResult[]): string[];

package/src/utils/sync-generators.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSyncGeneratorChanges = getSyncGeneratorChanges;
+exports.flushSyncGeneratorChanges = flushSyncGeneratorChanges;
+exports.collectAllRegisteredSyncGenerators = collectAllRegisteredSyncGenerators;
+exports.runSyncGenerator = runSyncGenerator;
+exports.collectRegisteredTaskSyncGenerators = collectRegisteredTaskSyncGenerators;
+exports.collectRegisteredGlobalSyncGenerators = collectRegisteredGlobalSyncGenerators;
+exports.syncGeneratorResultsToMessageLines = syncGeneratorResultsToMessageLines;
+const perf_hooks_1 = require("perf_hooks");
+const generate_1 = require("../command-line/generate/generate");
+const generator_utils_1 = require("../command-line/generate/generator-utils");
+const nx_json_1 = require("../config/nx-json");
+const client_1 = require("../daemon/client/client");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const tree_1 = require("../generators/tree");
+const project_graph_1 = require("../project-graph/project-graph");
+const workspace_context_1 = require("./workspace-context");
+const workspace_root_1 = require("./workspace-root");
+const chalk = require("chalk");
+async function getSyncGeneratorChanges(generators) {
+    perf_hooks_1.performance.mark('get-sync-generators-changes:start');
+    let results;
+    if (!client_1.daemonClient.enabled()) {
+        results = await runSyncGenerators(generators);
+    }
+    else {
+        results = await client_1.daemonClient.getSyncGeneratorChanges(generators);
+    }
+    perf_hooks_1.performance.mark('get-sync-generators-changes:end');
+    perf_hooks_1.performance.measure('get-sync-generators-changes', 'get-sync-generators-changes:start', 'get-sync-generators-changes:end');
+    return results.filter((r) => r.changes.length > 0);
+}
+async function flushSyncGeneratorChanges(results) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        await flushSyncGeneratorChangesToDisk(results);
+    }
+    else {
+        await client_1.daemonClient.flushSyncGeneratorChangesToDisk(results.map((r) => r.generatorName));
+    }
+}
+async function collectAllRegisteredSyncGenerators(projectGraph) {
+    if (!client_1.daemonClient.enabled()) {
+        return [
+            ...collectRegisteredTaskSyncGenerators(projectGraph),
+            ...collectRegisteredGlobalSyncGenerators(),
+        ];
+    }
+    return await client_1.daemonClient.getRegisteredSyncGenerators();
+}
+async function runSyncGenerator(tree, generatorSpecifier, projects) {
+    perf_hooks_1.performance.mark(`run-sync-generator:${generatorSpecifier}:start`);
+    const { collection, generator } = (0, generate_1.parseGeneratorString)(generatorSpecifier);
+    const { implementationFactory } = (0, generator_utils_1.getGeneratorInformation)(collection, generator, workspace_root_1.workspaceRoot, projects);
+    const implementation = implementationFactory();
+    const result = await implementation(tree);
+    let callback;
+    let outOfSyncMessage;
+    if (result && typeof result === 'object') {
+        callback = result.callback;
+        outOfSyncMessage = result.outOfSyncMessage;
+    }
+    perf_hooks_1.performance.mark(`run-sync-generator:${generatorSpecifier}:end`);
+    perf_hooks_1.performance.measure(`run-sync-generator:${generatorSpecifier}`, `run-sync-generator:${generatorSpecifier}:start`, `run-sync-generator:${generatorSpecifier}:end`);
+    return {
+        changes: tree.listChanges(),
+        generatorName: generatorSpecifier,
+        callback,
+        outOfSyncMessage,
+    };
+}
+function collectRegisteredTaskSyncGenerators(projectGraph) {
+    const taskSyncGenerators = new Set();
+    for (const { data: { targets }, } of Object.values(projectGraph.nodes)) {
+        if (!targets) {
+            continue;
+        }
+        for (const target of Object.values(targets)) {
+            if (!target.syncGenerators) {
+                continue;
+            }
+            for (const generator of target.syncGenerators) {
+                taskSyncGenerators.add(generator);
+            }
+        }
+    }
+    return taskSyncGenerators;
+}
+function collectRegisteredGlobalSyncGenerators(nxJson = (0, nx_json_1.readNxJson)()) {
+    const globalSyncGenerators = new Set();
+    if (!nxJson.sync?.globalGenerators?.length) {
+        return globalSyncGenerators;
+    }
+    for (const generator of nxJson.sync.globalGenerators) {
+        globalSyncGenerators.add(generator);
+    }
+    return globalSyncGenerators;
+}
+function syncGeneratorResultsToMessageLines(results) {
+    const messageLines = [];
+    for (const result of results) {
+        messageLines.push(`The ${chalk.bold(result.generatorName)} sync generator identified ${chalk.bold(result.changes.length)} file${result.changes.length === 1 ? '' : 's'} in the workspace that ${result.changes.length === 1 ? 'is' : 'are'} out of sync${result.outOfSyncMessage ? ':' : '.'}`);
+        if (result.outOfSyncMessage) {
+            messageLines.push(result.outOfSyncMessage);
+        }
+        messageLines.push('');
+    }
+    return messageLines;
+}
+async function runSyncGenerators(generators) {
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, 'running sync generators');
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const results = [];
+    for (const generator of generators) {
+        const result = await runSyncGenerator(tree, generator, projects);
+        results.push(result);
+    }
+    return results;
+}
+async function flushSyncGeneratorChangesToDisk(results) {
+    perf_hooks_1.performance.mark('flush-sync-generator-changes-to-disk:start');
+    const { changes, createdFiles, updatedFiles, deletedFiles, callbacks } = processSyncGeneratorResults(results);
+    // Write changes to disk
+    (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, changes);
+    // Run the callbacks
+    if (callbacks.length) {
+        for (const callback of callbacks) {
+            await callback();
+        }
+    }
+    // Update the context files
+    await (0, workspace_context_1.updateContextWithChangedFiles)(createdFiles, updatedFiles, deletedFiles);
+    perf_hooks_1.performance.mark('flush-sync-generator-changes-to-disk:end');
+    perf_hooks_1.performance.measure('flush sync generator changes to disk', 'flush-sync-generator-changes-to-disk:start', 'flush-sync-generator-changes-to-disk:end');
+}
+function processSyncGeneratorResults(results) {
+    const changes = [];
+    const createdFiles = [];
+    const updatedFiles = [];
+    const deletedFiles = [];
+    const callbacks = [];
+    for (const result of results) {
+        if (result.callback) {
+            callbacks.push(result.callback);
+        }
+        for (const change of result.changes) {
+            changes.push(change);
+            if (change.type === 'CREATE') {
+                createdFiles.push(change.path);
+            }
+            else if (change.type === 'UPDATE') {
+                updatedFiles.push(change.path);
+            }
+            else if (change.type === 'DELETE') {
+                deletedFiles.push(change.path);
+            }
+        }
+    }
+    return { changes, createdFiles, updatedFiles, deletedFiles, callbacks };
+}

package/src/utils/workspace-context.d.ts

@@ -11,6 +11,7 @@ export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, pr
 export declare function globWithWorkspaceContextSync(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
 export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[]>;
 export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string>;
+export declare function updateContextWithChangedFiles(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
 export declare function updateFilesInContext(updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
 export declare function getAllFileDataInContext(workspaceRoot: string): Promise<import("../native").FileData[]>;
 export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): Promise<string[]>;