nx 19.7.2 → 19.8.0-canary.20240911-2a3307c

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.7.2",
+  "version": "19.8.0-canary.20240911-2a3307c",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -71,7 +71,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.7.2"
+    "@nrwl/tao": "19.8.0-canary.20240911-2a3307c"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.7.2",
-    "@nx/nx-darwin-arm64": "19.7.2",
-    "@nx/nx-linux-x64-gnu": "19.7.2",
-    "@nx/nx-linux-x64-musl": "19.7.2",
-    "@nx/nx-win32-x64-msvc": "19.7.2",
-    "@nx/nx-linux-arm64-gnu": "19.7.2",
-    "@nx/nx-linux-arm64-musl": "19.7.2",
-    "@nx/nx-linux-arm-gnueabihf": "19.7.2",
-    "@nx/nx-win32-arm64-msvc": "19.7.2",
-    "@nx/nx-freebsd-x64": "19.7.2"
+    "@nx/nx-darwin-x64": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-darwin-arm64": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-linux-x64-gnu": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-linux-x64-musl": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-win32-x64-msvc": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-linux-arm64-gnu": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-linux-arm64-musl": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-linux-arm-gnueabihf": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-win32-arm64-msvc": "19.8.0-canary.20240911-2a3307c",
+    "@nx/nx-freebsd-x64": "19.8.0-canary.20240911-2a3307c"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/import/command-object.js

@@ -5,19 +5,21 @@ const documentation_1 = require("../yargs-utils/documentation");
 const shared_options_1 = require("../yargs-utils/shared-options");
 const params_1 = require("../../utils/params");
 exports.yargsImportCommand = {
-    command: 'import [sourceRemoteUrl] [destination]',
+    command: 'import [sourceRepository] [destinationDirectory]',
     describe: false,
     builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withVerbose)(yargs
-        .positional('sourceRemoteUrl', {
+        .positional('sourceRepository', {
         type: 'string',
         description: 'The remote URL of the source to import.',
     })
-        .positional('destination', {
+        .positional('destinationDirectory', {
         type: 'string',
+        alias: 'destination',
         description: 'The directory in the current workspace to import into.',
     })
-        .option('source', {
+        .option('sourceDirectory', {
         type: 'string',
+        alias: 'source',
         description: 'The directory in the source repository to import from.',
     })
         .option('ref', {

package/src/command-line/import/import.d.ts

@@ -2,7 +2,7 @@ export interface ImportOptions {
     /**
      * The remote URL of the repository to import
      */
-    sourceRemoteUrl: string;
+    sourceRepository: string;
     /**
      * The branch or reference to import
      */

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

@@ -25,41 +25,40 @@ const needs_install_1 = require("./utils/needs-install");
 const file_utils_1 = require("../../project-graph/file-utils");
 const importRemoteName = '__tmp_nx_import__';
 async function importHandler(options) {
-    let { sourceRemoteUrl, ref, source, destination } = options;
+    let { sourceRepository, ref, source, destination } = options;
     output_1.output.log({
-        title: 'Nx will walk you through the process of importing code from another repository into this workspace:',
+        title: 'Nx will walk you through the process of importing code from the source repository into this repository:',
         bodyLines: [
-            `1. Nx will clone the other repository into a temporary directory`,
-            `2. Code to be imported will be moved to the same directory it will be imported into on a temporary branch`,
-            `3. The code will be merged into the current branch in this workspace`,
-            `4. Nx will recommend plugins to integrate tools used in the imported code with Nx`,
-            `5. The code will be successfully imported into this workspace`,
+            `1. Nx will clone the source repository into a temporary directory`,
+            `2. The project code from the sourceDirectory will be moved to the destinationDirectory on a temporary branch in this repository`,
+            `3. The temporary branch will be merged into the current branch in this repository`,
+            `4. Nx will recommend plugins to integrate any new tools used in the imported code`,
             '',
-            `Git history will be preserved during this process`,
+            `Git history will be preserved during this process as long as you MERGE these changes. Do NOT squash and do NOT rebase the changes when merging branches.  If you would like to UNDO these changes, run "git reset HEAD~1 --hard"`,
         ],
     });
     const tempImportDirectory = (0, path_1.join)(tmp_1.tmpdir, 'nx-import');
-    if (!sourceRemoteUrl) {
-        sourceRemoteUrl = (await (0, enquirer_1.prompt)([
+    if (!sourceRepository) {
+        sourceRepository = (await (0, enquirer_1.prompt)([
             {
                 type: 'input',
-                name: 'sourceRemoteUrl',
+                name: 'sourceRepository',
                 message: 'What is the URL of the repository you want to import? (This can be a local git repository or a git remote URL)',
                 required: true,
             },
-        ])).sourceRemoteUrl;
+        ])).sourceRepository;
     }
     try {
-        const maybeLocalDirectory = await (0, promises_1.stat)(sourceRemoteUrl);
+        const maybeLocalDirectory = await (0, promises_1.stat)(sourceRepository);
         if (maybeLocalDirectory.isDirectory()) {
-            sourceRemoteUrl = (0, path_1.resolve)(sourceRemoteUrl);
+            sourceRepository = (0, path_1.resolve)(sourceRepository);
         }
     }
     catch (e) {
         // It's a remote url
     }
-    const sourceRepoPath = (0, path_1.join)(tempImportDirectory, 'repo');
-    const spinner = createSpinner(`Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath} (Use --depth to limit commit history and speed up clone times)`).start();
+    const sourceTempRepoPath = (0, path_1.join)(tempImportDirectory, 'repo');
+    const spinner = createSpinner(`Cloning ${sourceRepository} into a temporary directory: ${sourceTempRepoPath} (Use --depth to limit commit history and speed up clone times)`).start();
     try {
         await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
     }
@@ -67,17 +66,17 @@ async function importHandler(options) {
     await (0, promises_1.mkdir)(tempImportDirectory, { recursive: true });
     let sourceGitClient;
     try {
-        sourceGitClient = await (0, git_utils_1.cloneFromUpstream)(sourceRemoteUrl, sourceRepoPath, {
+        sourceGitClient = await (0, git_utils_1.cloneFromUpstream)(sourceRepository, sourceTempRepoPath, {
             originName: importRemoteName,
             depth: options.depth,
         });
     }
     catch (e) {
-        spinner.fail(`Failed to clone ${sourceRemoteUrl} into ${sourceRepoPath}`);
-        let errorMessage = `Failed to clone ${sourceRemoteUrl} into ${sourceRepoPath}. Please double check the remote and try again.\n${e.message}`;
+        spinner.fail(`Failed to clone ${sourceRepository} into ${sourceTempRepoPath}`);
+        let errorMessage = `Failed to clone ${sourceRepository} into ${sourceTempRepoPath}. Please double check the remote and try again.\n${e.message}`;
         throw new Error(errorMessage);
     }
-    spinner.succeed(`Cloned into ${sourceRepoPath}`);
+    spinner.succeed(`Cloned into ${sourceTempRepoPath}`);
     // Detecting the package manager before preparing the source repo for import.
     const sourcePackageManager = (0, package_manager_1.detectPackageManager)(sourceGitClient.root);
     if (!ref) {
@@ -116,14 +115,14 @@ async function importHandler(options) {
             },
         ])).destination;
     }
-    const absSource = (0, path_1.join)(sourceRepoPath, source);
+    const absSource = (0, path_1.join)(sourceTempRepoPath, source);
     const absDestination = (0, path_1.join)(process.cwd(), destination);
     const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
     await assertDestinationEmpty(destinationGitClient, absDestination);
     const tempImportBranch = getTempImportBranch(ref);
     await sourceGitClient.addFetchRemote(importRemoteName, ref);
     await sourceGitClient.fetch(importRemoteName, ref);
-    spinner.succeed(`Fetched ${ref} from ${sourceRemoteUrl}`);
+    spinner.succeed(`Fetched ${ref} from ${sourceRepository}`);
     spinner.start(`Checking out a temporary branch, ${tempImportBranch} based on ${ref}`);
     await sourceGitClient.checkout(tempImportBranch, {
         new: true,
@@ -134,14 +133,14 @@ async function importHandler(options) {
         await (0, promises_1.stat)(absSource);
     }
     catch (e) {
-        throw new Error(`The source directory ${source} does not exist in ${sourceRemoteUrl}. Please double check to make sure it exists.`);
+        throw new Error(`The source directory ${source} does not exist in ${sourceRepository}. Please double check to make sure it exists.`);
     }
     const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
     const originalPackageWorkspaces = await (0, needs_install_1.getPackagesInPackageManagerWorkspace)(packageManager);
     const relativeDestination = (0, path_1.relative)(destinationGitClient.root, absDestination);
-    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl);
-    await createTemporaryRemote(destinationGitClient, (0, path_1.join)(sourceRepoPath, '.git'), importRemoteName);
-    await (0, merge_remote_source_1.mergeRemoteSource)(destinationGitClient, sourceRemoteUrl, tempImportBranch, destination, importRemoteName, ref);
+    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRepository);
+    await createTemporaryRemote(destinationGitClient, (0, path_1.join)(sourceTempRepoPath, '.git'), importRemoteName);
+    await (0, merge_remote_source_1.mergeRemoteSource)(destinationGitClient, sourceRepository, tempImportBranch, destination, importRemoteName, ref);
     spinner.start('Cleaning up temporary files and remotes');
     await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
     await destinationGitClient.deleteGitRemote(importRemoteName);
@@ -208,7 +207,7 @@ async function importHandler(options) {
         output_1.output.log({
             title: `Check root dependencies`,
             bodyLines: [
-                `"dependencies" and "devDependencies" are not imported from the source repository (${sourceRemoteUrl}).`,
+                `"dependencies" and "devDependencies" are not imported from the source repository (${sourceRepository}).`,
                 `You may need to add some of those dependencies to this workspace in order to run tasks successfully.`,
             ],
         });

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

@@ -32,24 +32,82 @@ function syncHandler(options) {
             });
             return 0;
         }
+        const { failedGeneratorsCount, areAllResultsFailures, anySyncGeneratorsFailed, } = (0, sync_generators_1.processSyncGeneratorResultErrors)(results);
+        const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, options.verbose);
+        if (areAllResultsFailures) {
+            output_1.output.error({
+                title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            return 1;
+        }
+        const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
         if (options.check) {
             output_1.output.error({
-                title: `The workspace is out of sync`,
-                bodyLines: (0, sync_generators_1.syncGeneratorResultsToMessageLines)(results),
+                title: 'The workspace is out of sync',
+                bodyLines: resultBodyLines,
             });
+            if (anySyncGeneratorsFailed) {
+                output_1.output.error({
+                    title: failedGeneratorsCount === 1
+                        ? 'A sync generator failed to run'
+                        : 'Some sync generators failed to run',
+                    bodyLines: failedSyncGeneratorsFixMessageLines,
+                });
+            }
             return 1;
         }
         output_1.output.warn({
-            title: `The workspace is out of sync`,
-            bodyLines: (0, sync_generators_1.syncGeneratorResultsToMessageLines)(results),
+            title: 'The workspace is out of sync',
+            bodyLines: resultBodyLines,
         });
         const spinner = ora('Syncing the workspace...');
         spinner.start();
-        await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
-        spinner.succeed(`The workspace was synced successfully!
-
-Please make sure to commit the changes to your repository.
-`);
+        try {
+            const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+            if ('generatorFailures' in flushResult) {
+                spinner.fail();
+                output_1.output.error({
+                    title: 'Failed to sync the workspace',
+                    bodyLines: (0, sync_generators_1.getFlushFailureMessageLines)(flushResult, options.verbose),
+                });
+                return 1;
+            }
+        }
+        catch (e) {
+            spinner.fail();
+            output_1.output.error({
+                title: 'Failed to sync the workspace',
+                bodyLines: [
+                    'Syncing the workspace failed with the following error:',
+                    '',
+                    e.message,
+                    ...(options.verbose && !!e.stack ? [`\n${e.stack}`] : []),
+                    '',
+                    'Please rerun with `--verbose` and report the error at: https://github.com/nrwl/nx/issues/new/choose',
+                ],
+            });
+            return 1;
+        }
+        const successTitle = anySyncGeneratorsFailed
+            ? // the identified changes were synced successfully, but the workspace
+                // is still not up to date, which we'll mention next
+                'The identified changes were synced successfully!'
+            : // the workspace is fully up to date
+                'The workspace was synced successfully!';
+        const successSubtitle = 'Please make sure to commit the changes to your repository.';
+        spinner.succeed(`${successTitle}\n\n${successSubtitle}`);
+        if (anySyncGeneratorsFailed) {
+            output_1.output.error({
+                title: `The workspace is probably still out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            return 1;
+        }
         return 0;
     });
 }

package/src/daemon/client/client.d.ts

@@ -4,7 +4,7 @@ import { Hash } from '../../hasher/task-hasher';
 import { Task, TaskGraph } from '../../config/task-graph';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
 import { NxWorkspaceFiles, TaskRun } from '../../native';
-import type { SyncGeneratorChangesResult } from '../../utils/sync-generators';
+import type { FlushSyncGeneratorChangesResult, SyncGeneratorRunResult } from '../../utils/sync-generators';
 export type UnregisterCallback = () => void;
 export type ChangedFile = {
     path: string;
@@ -52,8 +52,8 @@ export declare class DaemonClient {
     hashGlob(globs: string[], exclude?: string[]): Promise<string>;
     getFlakyTasks(hashes: string[]): Promise<string[]>;
     recordTaskRuns(taskRuns: TaskRun[]): Promise<void>;
-    getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
-    flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
+    getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorRunResult[]>;
+    flushSyncGeneratorChangesToDisk(generators: string[]): Promise<FlushSyncGeneratorChangesResult>;
     getRegisteredSyncGenerators(): Promise<string[]>;
     updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
     isServerAvailable(): Promise<boolean>;

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleFlushSyncGeneratorChangesToDisk = handleFlushSyncGeneratorChangesToDisk;
 const sync_generators_1 = require("./sync-generators");
 async function handleFlushSyncGeneratorChangesToDisk(generators) {
-    await (0, sync_generators_1.flushSyncGeneratorChangesToDisk)(generators);
+    const result = await (0, sync_generators_1.flushSyncGeneratorChangesToDisk)(generators);
     return {
-        response: '{}',
+        response: JSON.stringify(result),
         description: 'handleFlushSyncGeneratorChangesToDisk',
     };
 }

package/src/daemon/server/handle-get-sync-generator-changes.js

@@ -4,12 +4,14 @@ exports.handleGetSyncGeneratorChanges = handleGetSyncGeneratorChanges;
 const sync_generators_1 = require("./sync-generators");
 async function handleGetSyncGeneratorChanges(generators) {
     const changes = await (0, sync_generators_1.getCachedSyncGeneratorChanges)(generators);
-    // strip out the content of the changes and any potential callback
-    const result = changes.map((change) => ({
-        generatorName: change.generatorName,
-        changes: change.changes.map((c) => ({ ...c, content: null })),
-        outOfSyncMessage: change.outOfSyncMessage,
-    }));
+    const result = changes.map((change) => 'error' in change
+        ? change
+        : // strip out the content of the changes and any potential callback
+            {
+                generatorName: change.generatorName,
+                changes: change.changes.map((c) => ({ ...c, content: null })),
+                outOfSyncMessage: change.outOfSyncMessage,
+            });
     return {
         response: JSON.stringify(result),
         description: 'handleGetSyncGeneratorChanges',

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

@@ -1,10 +1,10 @@
 import type { ProjectGraph } from '../../config/project-graph';
-import { type SyncGeneratorChangesResult } from '../../utils/sync-generators';
-export declare function getCachedSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
-export declare function flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
+import { type FlushSyncGeneratorChangesResult, type SyncGeneratorRunResult } from '../../utils/sync-generators';
+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<string[]>;
 /**
  * @internal
  */
-export declare function _getConflictingGeneratorGroups(results: SyncGeneratorChangesResult[]): string[][];
+export declare function _getConflictingGeneratorGroups(results: SyncGeneratorRunResult[]): string[][];

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

@@ -59,7 +59,7 @@ async function flushSyncGeneratorChangesToDisk(generators) {
     for (const generator of generators) {
         syncGeneratorsCacheResultPromises.delete(generator);
     }
-    await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+    return await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
 }
 function collectAndScheduleSyncGenerators(projectGraph) {
     if (!projectGraph) {
@@ -191,6 +191,7 @@ 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
@@ -234,6 +235,9 @@ async function processConflictingGenerators(conflicts, initialResults) {
 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());
@@ -318,7 +322,12 @@ function runGenerator(generator, projects, tree) {
     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) => {
-        log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
+        if ('error' in result) {
+            log(generator, 'error:', result.error.message);
+        }
+        else {
+            log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
+        }
         return result;
     });
 }

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

@@ -11,6 +11,7 @@ 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 native_1 = require("../native");
 const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
 const is_ci_1 = require("../utils/is-ci");
@@ -33,7 +34,6 @@ 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");
-const native_1 = require("../native");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -135,14 +135,49 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         // There are no changes to sync, workspace is up to date
         return { projectGraph, taskGraph };
     }
+    const { failedGeneratorsCount, areAllResultsFailures, anySyncGeneratorsFailed, } = (0, sync_generators_1.processSyncGeneratorResultErrors)(results);
+    const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, nxArgs.verbose);
     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 in interactive environments.';
-    const willErrorOnCiMessage = 'Please note that this will be an error on CI.';
+    const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
+    const fixMessage = 'You can manually run `nx sync` to update your workspace with the identified changes or you can set `sync.applyChanges` to `true` in your `nx.json` to apply the changes automatically when running tasks in interactive environments.';
+    const willErrorOnCiMessage = 'Please note that having the workspace out of sync will result in an error in 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 (areAllResultsFailures) {
+            output_1.output.error({
+                title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+        }
+        else {
+            output_1.output.error({
+                title: outOfSyncTitle,
+                bodyLines: [...resultBodyLines, '', fixMessage],
+            });
+            if (anySyncGeneratorsFailed) {
+                output_1.output.error({
+                    title: failedGeneratorsCount === 1
+                        ? 'A sync generator failed to run'
+                        : 'Some sync generators failed to run',
+                    bodyLines: failedSyncGeneratorsFixMessageLines,
+                });
+            }
+        }
+        process.exit(1);
+    }
+    if (areAllResultsFailures) {
+        output_1.output.warn({
+            title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                ? 'a sync generator'
+                : 'some sync generators'} failed to run`,
+            bodyLines: failedSyncGeneratorsFixMessageLines,
+        });
+        await confirmRunningTasksWithSyncFailures();
+        // if all sync generators failed to run there's nothing to sync, we just let the tasks run
+        return { projectGraph, taskGraph };
     }
     if (nxJson.sync?.applyChanges === false) {
         // If the user has set `sync.applyChanges` to `false` in their `nx.json`
@@ -153,19 +188,30 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
             title: outOfSyncTitle,
             bodyLines: [
                 ...resultBodyLines,
-                'Your workspace is set to not apply changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
+                '',
+                'Your workspace is set to not apply the identified changes automatically (`sync.applyChanges` is set to `false` in your `nx.json`).',
                 willErrorOnCiMessage,
                 fixMessage,
             ],
         });
+        if (anySyncGeneratorsFailed) {
+            output_1.output.warn({
+                title: failedGeneratorsCount === 1
+                    ? 'A sync generator failed to run'
+                    : 'Some sync generators failed to run',
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            await confirmRunningTasksWithSyncFailures();
+        }
         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`).'
+                ? 'Proceeding to sync the identified changes automatically (`sync.applyChanges` is set to `true` in your `nx.json`).'
                 : willErrorOnCiMessage,
         ],
     });
@@ -175,31 +221,66 @@ async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, project
         const spinner = ora('Syncing the workspace...');
         spinner.start();
         // Flush sync generator changes to disk
-        await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+        const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+        if ('generatorFailures' in flushResult) {
+            spinner.fail();
+            output_1.output.error({
+                title: 'Failed to sync the workspace',
+                bodyLines: [
+                    ...(0, sync_generators_1.getFlushFailureMessageLines)(flushResult, nxArgs.verbose),
+                    ...(flushResult.generalFailure
+                        ? [
+                            'If needed, you can run the tasks with the `--skip-sync` flag to disable syncing.',
+                        ]
+                        : []),
+                ],
+            });
+            await confirmRunningTasksWithSyncFailures();
+        }
         // 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.`);
+        const successTitle = anySyncGeneratorsFailed
+            ? // the identified changes were synced successfully, but the workspace
+                // is still not up to date, which we'll mention next
+                'The identified changes were synced successfully!'
+            : // the workspace is fully up to date
+                'The workspace was synced successfully!';
+        const successSubtitle = nxJson.sync?.applyChanges === true
+            ? 'Please make sure to commit the changes to your repository or this will error in CI.'
+            : // The user was prompted and we already logged a message about erroring in CI
+                // so here we just tell them to commit the changes.
+                'Please make sure to commit the changes to your repository.';
+        spinner.succeed(`${successTitle}\n\n${successSubtitle}`);
+        if (anySyncGeneratorsFailed) {
+            output_1.output.warn({
+                title: `The workspace is probably still out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            await confirmRunningTasksWithSyncFailures();
         }
     }
     else {
-        output_1.output.warn({
-            title: 'Syncing the workspace was skipped',
-            bodyLines: [
-                'This could lead to unexpected results or errors when running tasks.',
-                fixMessage,
-            ],
-        });
+        if (anySyncGeneratorsFailed) {
+            output_1.output.warn({
+                title: failedGeneratorsCount === 1
+                    ? 'A sync generator failed to report the sync status'
+                    : 'Some sync generators failed to report the sync status',
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            await confirmRunningTasksWithSyncFailures();
+        }
+        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 };
 }
@@ -208,7 +289,7 @@ async function promptForApplyingSyncGeneratorChanges() {
         const promptConfig = {
             name: 'applyChanges',
             type: 'select',
-            message: 'Would you like to sync the changes to get your worskpace up to date?',
+            message: 'Would you like to sync the identified changes to get your worskpace up to date?',
             choices: [
                 {
                     name: 'yes',
@@ -227,6 +308,35 @@ async function promptForApplyingSyncGeneratorChanges() {
         process.exit(1);
     }
 }
+async function confirmRunningTasksWithSyncFailures() {
+    try {
+        const promptConfig = {
+            name: 'runTasks',
+            type: 'select',
+            message: 'Would you like to ignore the sync failures and continue running the tasks?',
+            choices: [
+                {
+                    name: 'yes',
+                    message: 'Yes, ignore the failures and run the tasks',
+                },
+                {
+                    name: 'no',
+                    message: `No, don't run the tasks`,
+                },
+            ],
+            footer: () => chalk.dim(`\nWhen running in CI and there are sync failures, the tasks won't run. Addressing the errors above is highly recommended to prevent failures in CI.`),
+        };
+        const runTasks = await (0, enquirer_1.prompt)([
+            promptConfig,
+        ]).then(({ runTasks }) => runTasks === 'yes');
+        if (!runTasks) {
+            process.exit(1);
+        }
+    }
+    catch {
+        process.exit(1);
+    }
+}
 function setEnvVarsBasedOnArgs(nxArgs, loadDotEnvFiles) {
     if (nxArgs.outputStyle == 'stream' ||
         process.env.NX_BATCH_MODE === 'true' ||

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

@@ -9,17 +9,46 @@ export type SyncGeneratorResult = void | {
     outOfSyncMessage?: string;
 };
 export type SyncGenerator = (tree: Tree) => SyncGeneratorResult | Promise<SyncGeneratorResult>;
-export type SyncGeneratorChangesResult = {
-    changes: FileChange[];
+export type SyncGeneratorRunSuccessResult = {
     generatorName: string;
+    changes: FileChange[];
     callback?: GeneratorCallback;
     outOfSyncMessage?: string;
 };
-export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
-export declare function flushSyncGeneratorChanges(results: SyncGeneratorChangesResult[]): Promise<void>;
+type SerializableSimpleError = {
+    message: string;
+    stack: string | undefined;
+};
+export type SyncGeneratorRunErrorResult = {
+    generatorName: string;
+    error: SerializableSimpleError;
+};
+export type SyncGeneratorRunResult = SyncGeneratorRunSuccessResult | SyncGeneratorRunErrorResult;
+type FlushSyncGeneratorChangesSuccess = {
+    success: true;
+};
+type FlushSyncGeneratorFailure = {
+    generator: string;
+    error: SerializableSimpleError;
+};
+type FlushSyncGeneratorChangesFailure = {
+    generatorFailures: FlushSyncGeneratorFailure[];
+    generalFailure?: SerializableSimpleError;
+};
+export type FlushSyncGeneratorChangesResult = FlushSyncGeneratorChangesSuccess | FlushSyncGeneratorChangesFailure;
+export declare function getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorRunResult[]>;
+export declare function flushSyncGeneratorChanges(results: SyncGeneratorRunResult[]): Promise<FlushSyncGeneratorChangesResult>;
 export declare function collectAllRegisteredSyncGenerators(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Promise<string[]>;
-export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorChangesResult>;
+export declare function runSyncGenerator(tree: Tree, generatorSpecifier: string, projects: Record<string, ProjectConfiguration>): Promise<SyncGeneratorRunResult>;
 export declare function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectEnabledTaskSyncGeneratorsFromTaskGraph(taskGraph: TaskGraph, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): Set<string>;
 export declare function collectRegisteredGlobalSyncGenerators(nxJson?: NxJsonConfiguration<string[] | "*">): Set<string>;
-export declare function syncGeneratorResultsToMessageLines(results: SyncGeneratorChangesResult[]): string[];
+export declare function getSyncGeneratorSuccessResultsMessageLines(results: SyncGeneratorRunResult[]): string[];
+export declare function getFailedSyncGeneratorsFixMessageLines(results: SyncGeneratorRunResult[], verbose: boolean): string[];
+export declare function getFlushFailureMessageLines(result: FlushSyncGeneratorChangesFailure, verbose: boolean): string[];
+export declare function processSyncGeneratorResultErrors(results: SyncGeneratorRunResult[]): {
+    failedGeneratorsCount: number;
+    areAllResultsFailures: boolean;
+    anySyncGeneratorsFailed: boolean;
+};
+export {};

package/src/utils/sync-generators.js

@@ -7,7 +7,10 @@ exports.runSyncGenerator = runSyncGenerator;
 exports.collectEnabledTaskSyncGeneratorsFromProjectGraph = collectEnabledTaskSyncGeneratorsFromProjectGraph;
 exports.collectEnabledTaskSyncGeneratorsFromTaskGraph = collectEnabledTaskSyncGeneratorsFromTaskGraph;
 exports.collectRegisteredGlobalSyncGenerators = collectRegisteredGlobalSyncGenerators;
-exports.syncGeneratorResultsToMessageLines = syncGeneratorResultsToMessageLines;
+exports.getSyncGeneratorSuccessResultsMessageLines = getSyncGeneratorSuccessResultsMessageLines;
+exports.getFailedSyncGeneratorsFixMessageLines = getFailedSyncGeneratorsFixMessageLines;
+exports.getFlushFailureMessageLines = getFlushFailureMessageLines;
+exports.processSyncGeneratorResultErrors = processSyncGeneratorResultErrors;
 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");
@@ -30,15 +33,13 @@ async function 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);
+    return results.filter((r) => ('error' in r ? true : 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));
+        return await flushSyncGeneratorChangesToDisk(results);
     }
+    return await client_1.daemonClient.flushSyncGeneratorChangesToDisk(results.map((r) => r.generatorName));
 }
 async function collectAllRegisteredSyncGenerators(projectGraph, nxJson) {
     if (!client_1.daemonClient.enabled()) {
@@ -50,25 +51,33 @@ async function collectAllRegisteredSyncGenerators(projectGraph, nxJson) {
     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,
-    };
+    try {
+        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,
+        };
+    }
+    catch (e) {
+        return {
+            generatorName: generatorSpecifier,
+            error: { message: e.message, stack: e.stack },
+        };
+    }
 }
 function collectEnabledTaskSyncGeneratorsFromProjectGraph(projectGraph, nxJson) {
     const taskSyncGenerators = new Set();
@@ -118,9 +127,12 @@ function collectRegisteredGlobalSyncGenerators(nxJson = (0, nx_json_1.readNxJson
     }
     return globalSyncGenerators;
 }
-function syncGeneratorResultsToMessageLines(results) {
+function getSyncGeneratorSuccessResultsMessageLines(results) {
     const messageLines = [];
     for (const result of results) {
+        if ('error' in result) {
+            continue;
+        }
         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);
@@ -128,6 +140,65 @@ function syncGeneratorResultsToMessageLines(results) {
     }
     return messageLines;
 }
+function getFailedSyncGeneratorsFixMessageLines(results, verbose) {
+    const messageLines = [];
+    const generators = [];
+    for (const result of results) {
+        if ('error' in result) {
+            messageLines.push(`The ${chalk.bold(result.generatorName)} sync generator reported the following error:
+${chalk.bold(result.error.message)}${verbose && result.error.stack ? '\n' + result.error.stack : ''}`);
+            generators.push(result.generatorName);
+        }
+    }
+    messageLines.push(...getFailedSyncGeneratorsMessageLines(generators, verbose));
+    return messageLines;
+}
+function getFlushFailureMessageLines(result, verbose) {
+    const messageLines = [];
+    const generators = [];
+    for (const failure of result.generatorFailures) {
+        messageLines.push(`The ${chalk.bold(failure.generator)} sync generator failed to apply its changes with the following error:
+${chalk.bold(failure.error.message)}${verbose && failure.error.stack ? '\n' + failure.error.stack : ''}`);
+        generators.push(failure.generator);
+    }
+    messageLines.push(...getFailedSyncGeneratorsMessageLines(generators, verbose));
+    if (result.generalFailure) {
+        if (messageLines.length > 0) {
+            messageLines.push('');
+            messageLines.push('Additionally, an unexpected error occurred:');
+        }
+        else {
+            messageLines.push('An unexpected error occurred:');
+        }
+        messageLines.push(...[
+            '',
+            result.generalFailure.message,
+            ...(verbose && !!result.generalFailure.stack
+                ? [`\n${result.generalFailure.stack}`]
+                : []),
+            '',
+            verbose
+                ? 'Please report the error at: https://github.com/nrwl/nx/issues/new/choose'
+                : 'Please run with `--verbose` and report the error at: https://github.com/nrwl/nx/issues/new/choose',
+        ]);
+    }
+    return messageLines;
+}
+function processSyncGeneratorResultErrors(results) {
+    let failedGeneratorsCount = 0;
+    for (const result of results) {
+        if ('error' in result) {
+            failedGeneratorsCount++;
+        }
+    }
+    const areAllResultsFailures = failedGeneratorsCount === results.length;
+    const anySyncGeneratorsFailed = failedGeneratorsCount > 0;
+    return {
+        failedGeneratorsCount,
+        areAllResultsFailures,
+        anySyncGeneratorsFailed,
+    };
+}
 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)();
@@ -141,32 +212,15 @@ async function runSyncGenerators(generators) {
 }
 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 = [];
+    const generatorFailures = [];
     for (const result of results) {
-        if (result.callback) {
-            callbacks.push(result.callback);
+        if ('error' in result) {
+            continue;
         }
         for (const change of result.changes) {
-            changes.push(change);
             if (change.type === 'CREATE') {
                 createdFiles.push(change.path);
             }
@@ -177,6 +231,49 @@ function processSyncGeneratorResults(results) {
                 deletedFiles.push(change.path);
             }
         }
+        try {
+            // Write changes to disk
+            (0, tree_1.flushChanges)(workspace_root_1.workspaceRoot, result.changes);
+            // Run the callback
+            if (result.callback) {
+                await result.callback();
+            }
+        }
+        catch (e) {
+            generatorFailures.push({
+                generator: result.generatorName,
+                error: { message: e.message, stack: e.stack },
+            });
+        }
+    }
+    try {
+        // 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');
+    }
+    catch (e) {
+        return {
+            generatorFailures,
+            generalFailure: { message: e.message, stack: e.stack },
+        };
     }
-    return { changes, createdFiles, updatedFiles, deletedFiles, callbacks };
+    return generatorFailures.length > 0
+        ? { generatorFailures }
+        : { success: true };
+}
+function getFailedSyncGeneratorsMessageLines(generators, verbose) {
+    const messageLines = [];
+    if (generators.length === 1) {
+        messageLines.push('', verbose
+            ? 'Please check the error above and address the issue.'
+            : 'Please check the error above and address the issue. You can provide the `--verbose` flag to get more details.', `If needed, you can disable the failing sync generator by setting \`sync.disabledTaskSyncGenerators: ["${generators[0]}"]\` in your \`nx.json\`.`);
+    }
+    else if (generators.length > 1) {
+        const generatorsString = generators.map((g) => `"${g}"`).join(', ');
+        messageLines.push('', verbose
+            ? 'Please check the errors above and address the issues.'
+            : 'Please check the errors above and address the issues. You can provide the `--verbose` flag to get more details.', `If needed, you can disable the failing sync generators by setting \`sync.disabledTaskSyncGenerators: [${generatorsString}]\` in your \`nx.json\`.`);
+    }
+    return messageLines;
 }