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

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,116 @@ 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);
+    // 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/command-line-utils.d.ts

@@ -32,6 +32,7 @@ export interface NxArgs {
     excludeTaskDependencies?: boolean;
 }
 export declare function createOverrides(__overrides_unparsed__?: string[]): Record<string, any>;
+export declare function getBaseRef(nxJson: NxJsonConfiguration): string;
 export declare function splitArgsIntoNxArgsAndOverrides(args: {
     [k: string]: any;
 }, mode: 'run-one' | 'run-many' | 'affected' | 'print-affected', options: {

package/src/utils/command-line-utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createOverrides = createOverrides;
+exports.getBaseRef = getBaseRef;
 exports.splitArgsIntoNxArgsAndOverrides = splitArgsIntoNxArgsAndOverrides;
 exports.readParallelFromArgsAndEnv = readParallelFromArgsAndEnv;
 exports.parseFiles = parseFiles;
@@ -24,6 +25,9 @@ function createOverrides(__overrides_unparsed__ = []) {
     overrides.__overrides_unparsed__ = __overrides_unparsed__;
     return overrides;
 }
+function getBaseRef(nxJson) {
+    return nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+}
 function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings: true }, nxJson) {
     // this is to lerna case when this function is invoked imperatively
     if (args['target'] && !args['targets']) {
@@ -70,7 +74,7 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
                 ],
             });
         }
-        // Allow setting base and head via environment variables (lower priority then direct command arguments)
+        // Allow setting base and head via environment variables (lower priority than direct command arguments)
         if (!nxArgs.base && process.env.NX_BASE) {
             nxArgs.base = process.env.NX_BASE;
             if (options.printWarnings) {
@@ -88,8 +92,7 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
             }
         }
         if (!nxArgs.base) {
-            nxArgs.base =
-                nxJson.defaultBase ?? nxJson.affected?.defaultBase ?? 'main';
+            nxArgs.base = getBaseRef(nxJson);
             // No user-provided arguments to set the affected criteria, so inform the user of the defaults being used
             if (options.printWarnings &&
                 !nxArgs.head &&

package/src/utils/git-utils.d.ts

@@ -1,3 +1,38 @@
+import { ExecSyncOptions } from 'child_process';
+export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+    originName: string;
+}): Promise<GitRepository>;
+export declare class GitRepository {
+    private directory;
+    root: string;
+    constructor(directory: string);
+    getGitRootPath(cwd: string): string;
+    addFetchRemote(remoteName: string, branch: string): Promise<string>;
+    private execAsync;
+    showStat(): Promise<string>;
+    listBranches(): Promise<string[]>;
+    getGitFiles(path: string): Promise<string[]>;
+    reset(ref: string): Promise<string>;
+    squashLastTwoCommits(): Promise<string>;
+    mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
+    fetch(remote: string, ref?: string): Promise<string>;
+    checkout(branch: string, opts: {
+        new: boolean;
+        base: string;
+    }): Promise<string>;
+    move(path: string, destination: string): Promise<string>;
+    push(ref: string, remoteName: string): Promise<string>;
+    commit(message: string): Promise<string>;
+    amendCommit(): Promise<string>;
+    deleteGitRemote(name: string): Promise<string>;
+    deleteBranch(branch: string): Promise<string>;
+    addGitRemote(name: string, url: string): Promise<string>;
+}
+/**
+ * This is used by the squash editor script to update the rebase file.
+ */
+export declare function updateRebaseFile(contents: string): string;
+export declare function fetchGitRemote(name: string, branch: string, execOptions: ExecSyncOptions): string | Buffer;
 export declare function getGithubSlugOrNull(): string | null;
 export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
 export declare function commitChanges(commitMessage: string, directory?: string): string | null;

package/src/utils/git-utils.js

@@ -1,11 +1,122 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRepository = void 0;
+exports.cloneFromUpstream = cloneFromUpstream;
+exports.updateRebaseFile = updateRebaseFile;
+exports.fetchGitRemote = fetchGitRemote;
 exports.getGithubSlugOrNull = getGithubSlugOrNull;
 exports.extractUserAndRepoFromGitHubUrl = extractUserAndRepoFromGitHubUrl;
 exports.commitChanges = commitChanges;
 exports.getLatestCommitSha = getLatestCommitSha;
 const child_process_1 = require("child_process");
 const devkit_exports_1 = require("../devkit-exports");
+const path_1 = require("path");
+const SQUASH_EDITOR = (0, path_1.join)(__dirname, 'squash.js');
+function execAsync(command, execOptions) {
+    return new Promise((res, rej) => {
+        (0, child_process_1.exec)(command, execOptions, (err, stdout, stderr) => {
+            if (err) {
+                return rej(err);
+            }
+            res(stdout);
+        });
+    });
+}
+async function cloneFromUpstream(url, destination, { originName } = { originName: 'origin' }) {
+    await execAsync(`git clone ${url} ${destination} --depth 1 --origin ${originName}`, {
+        cwd: (0, path_1.dirname)(destination),
+    });
+    return new GitRepository(destination);
+}
+class GitRepository {
+    constructor(directory) {
+        this.directory = directory;
+        this.root = this.getGitRootPath(this.directory);
+    }
+    getGitRootPath(cwd) {
+        return (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+            cwd,
+        })
+            .toString()
+            .trim();
+    }
+    addFetchRemote(remoteName, branch) {
+        return this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
+    }
+    execAsync(command) {
+        return execAsync(command, {
+            cwd: this.root,
+        });
+    }
+    async showStat() {
+        return await this.execAsync(`git show --stat`);
+    }
+    async listBranches() {
+        return (await this.execAsync(`git ls-remote --heads --quiet`))
+            .trim()
+            .split('\n')
+            .map((s) => s
+            .trim()
+            .substring(s.indexOf('\t') + 1)
+            .replace('refs/heads/', ''));
+    }
+    async getGitFiles(path) {
+        return (await this.execAsync(`git ls-files ${path}`))
+            .trim()
+            .split('\n')
+            .map((s) => s.trim())
+            .filter(Boolean);
+    }
+    async reset(ref) {
+        return this.execAsync(`git reset ${ref} --hard`);
+    }
+    async squashLastTwoCommits() {
+        return this.execAsync(`git -c core.editor="node ${SQUASH_EDITOR}" rebase --interactive --no-autosquash HEAD~2`);
+    }
+    async mergeUnrelatedHistories(ref, message) {
+        return this.execAsync(`git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`);
+    }
+    async fetch(remote, ref) {
+        return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+    }
+    async checkout(branch, opts) {
+        return this.execAsync(`git checkout ${opts.new ? '-b ' : ' '}${branch}${opts.base ? ' ' + opts.base : ''}`);
+    }
+    async move(path, destination) {
+        return this.execAsync(`git mv ${path} ${destination}`);
+    }
+    async push(ref, remoteName) {
+        return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+    }
+    async commit(message) {
+        return this.execAsync(`git commit -am "${message}"`);
+    }
+    async amendCommit() {
+        return this.execAsync(`git commit --amend -a --no-edit`);
+    }
+    deleteGitRemote(name) {
+        return this.execAsync(`git remote rm ${name}`);
+    }
+    deleteBranch(branch) {
+        return this.execAsync(`git branch -D ${branch}`);
+    }
+    addGitRemote(name, url) {
+        return this.execAsync(`git remote add ${name} ${url}`);
+    }
+}
+exports.GitRepository = GitRepository;
+/**
+ * This is used by the squash editor script to update the rebase file.
+ */
+function updateRebaseFile(contents) {
+    const lines = contents.split('\n');
+    const lastCommitIndex = lines.findIndex((line) => line === '') - 1;
+    lines[lastCommitIndex] = lines[lastCommitIndex].replace('pick', 'fixup');
+    return lines.join('\n');
+}
+function fetchGitRemote(name, branch, execOptions) {
+    return (0, child_process_1.execSync)(`git fetch ${name} ${branch} --depth 1`, execOptions);
+}
 function getGithubSlugOrNull() {
     try {
         const gitRemote = (0, child_process_1.execSync)('git remote -v', {

package/src/utils/package-manager.js

@@ -49,7 +49,7 @@ function isWorkspacesEnabled(packageManager = detectPackageManager(), root = wor
     if (packageManager === 'pnpm') {
         return (0, fs_1.existsSync)((0, path_1.join)(root, 'pnpm-workspace.yaml'));
     }
-    // yarn and pnpm both use the same 'workspaces' property in package.json
+    // yarn and npm both use the same 'workspaces' property in package.json
     const packageJson = (0, file_utils_1.readPackageJson)();
     return !!packageJson?.workspaces;
 }

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

@@ -0,0 +1 @@
+export {};

package/src/utils/squash.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const git_utils_1 = require("./git-utils");
+// This script is used as an editor for git rebase -i
+// This is the file which git creates. When this script exits, the updates should be written to this file.
+const filePath = process.argv[2];
+// Change the second commit from pick to fixup
+const contents = (0, fs_1.readFileSync)(filePath).toString();
+const newContents = (0, git_utils_1.updateRebaseFile)(contents);
+// Write the updated contents back to the file
+(0, fs_1.writeFileSync)(filePath, newContents);

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)(workspace_root_1.workspaceRoot, 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,7 +11,8 @@ 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 updateFilesInContext(updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
+export declare function updateContextWithChangedFiles(workspaceRoot: string, createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
+export declare function updateFilesInContext(workspaceRoot: string, 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[]>;
 export declare function updateProjectFiles(projectRootMappings: Record<string, string>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): import("../native").UpdatedWorkspaceFiles;

package/src/utils/workspace-context.js

@@ -5,6 +5,7 @@ exports.getNxWorkspaceFilesFromContext = getNxWorkspaceFilesFromContext;
 exports.globWithWorkspaceContextSync = globWithWorkspaceContextSync;
 exports.globWithWorkspaceContext = globWithWorkspaceContext;
 exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
+exports.updateContextWithChangedFiles = updateContextWithChangedFiles;
 exports.updateFilesInContext = updateFilesInContext;
 exports.getAllFileDataInContext = getAllFileDataInContext;
 exports.getFilesInDirectoryUsingContext = getFilesInDirectoryUsingContext;
@@ -56,7 +57,23 @@ async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
     }
     return client_1.daemonClient.hashGlob(globs, exclude);
 }
-function updateFilesInContext(updatedFiles, deletedFiles) {
+async function updateContextWithChangedFiles(workspaceRoot, createdFiles, updatedFiles, deletedFiles) {
+    if (!client_1.daemonClient.enabled()) {
+        updateFilesInContext(workspaceRoot, [...createdFiles, ...updatedFiles], deletedFiles);
+    }
+    else if ((0, is_on_daemon_1.isOnDaemon)()) {
+        // make sure to only import this when running on the daemon
+        const { addUpdatedAndDeletedFiles } = await Promise.resolve().then(() => require('../daemon/server/project-graph-incremental-recomputation'));
+        // update files for the incremental graph recomputation on the daemon
+        addUpdatedAndDeletedFiles(createdFiles, updatedFiles, deletedFiles);
+    }
+    else {
+        // daemon is enabled but we are not running on it, ask the daemon to update the context
+        await client_1.daemonClient.updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles);
+    }
+}
+function updateFilesInContext(workspaceRoot, updatedFiles, deletedFiles) {
+    ensureContextAvailable(workspaceRoot);
     return workspaceContext?.incrementalUpdate(updatedFiles, deletedFiles);
 }
 async function getAllFileDataInContext(workspaceRoot) {

package/src/daemon/message-types/update-context-files.d.ts

@@ -1,7 +0,0 @@
-export declare const GLOB: "GLOB";
-export type HandleUpdateContextMessage = {
-    type: typeof GLOB;
-    updatedFiles: string[];
-    deletedFiles: string[];
-};
-export declare function isHandleUpdateContextMessage(message: unknown): message is HandleUpdateContextMessage;

package/src/daemon/message-types/update-context-files.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GLOB = void 0;
-exports.isHandleUpdateContextMessage = isHandleUpdateContextMessage;
-exports.GLOB = 'GLOB';
-function isHandleUpdateContextMessage(message) {
-    return (typeof message === 'object' &&
-        message !== null &&
-        'type' in message &&
-        message['type'] === exports.GLOB);
-}