nx 19.7.1 → 19.7.3

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

@@ -11,12 +11,13 @@ 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");
 const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const output_1 = require("../utils/output");
-const params_1 = require("../utils/params");
+const handle_errors_1 = require("../utils/handle-errors");
 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");
@@ -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;
@@ -98,7 +98,7 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
     return taskGraph;
 }
 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 status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
         const projectNames = projectsToRun.map((t) => t.name);
         const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
         const tasks = Object.values(taskGraph.tasks);
@@ -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/handle-errors.d.ts

@@ -0,0 +1 @@
+export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<number>;

package/src/utils/handle-errors.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleErrors = handleErrors;
+const client_1 = require("../daemon/client/client");
+const logger_1 = require("./logger");
+const output_1 = require("./output");
+async function handleErrors(isVerbose, fn) {
+    try {
+        const result = await fn();
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
+    }
+    catch (err) {
+        err ||= new Error('Unknown error caught');
+        if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
+            logger_1.logger.error('The generator workflow failed. See above.');
+        }
+        else if (err.name === 'ProjectGraphError') {
+            const projectGraphError = err;
+            let title = projectGraphError.message;
+            if (projectGraphError.cause &&
+                typeof projectGraphError.cause === 'object' &&
+                'message' in projectGraphError.cause) {
+                title += ' ' + projectGraphError.cause.message + '.';
+            }
+            if (isVerbose) {
+                title += ' See errors below.';
+            }
+            const bodyLines = isVerbose
+                ? formatErrorStackAndCause(projectGraphError)
+                : ['Pass --verbose to see the stacktraces.'];
+            output_1.output.error({
+                title,
+                bodyLines: bodyLines,
+            });
+        }
+        else {
+            const lines = (err.message ? err.message : err.toString()).split('\n');
+            const bodyLines = lines.slice(1);
+            if (isVerbose) {
+                bodyLines.push(...formatErrorStackAndCause(err));
+            }
+            else if (err.stack) {
+                bodyLines.push('Pass --verbose to see the stacktrace.');
+            }
+            output_1.output.error({
+                title: lines[0],
+                bodyLines,
+            });
+        }
+        if (client_1.daemonClient.enabled()) {
+            client_1.daemonClient.reset();
+        }
+        return 1;
+    }
+}
+function formatErrorStackAndCause(error) {
+    return [
+        error.stack || error.message,
+        ...(error.cause && typeof error.cause === 'object'
+            ? [
+                'Caused by:',
+                'stack' in error.cause
+                    ? error.cause.stack.toString()
+                    : error.cause.toString(),
+            ]
+            : []),
+    ];
+}

package/src/utils/nx-cloud-utils.d.ts

@@ -1,4 +1,3 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 export declare function isNxCloudUsed(nxJson: NxJsonConfiguration): boolean;
 export declare function getNxCloudUrl(nxJson: NxJsonConfiguration): string;
-export declare function getNxCloudToken(nxJson: NxJsonConfiguration): string;

package/src/utils/nx-cloud-utils.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isNxCloudUsed = isNxCloudUsed;
 exports.getNxCloudUrl = getNxCloudUrl;
-exports.getNxCloudToken = getNxCloudToken;
 function isNxCloudUsed(nxJson) {
     return (!!process.env.NX_CLOUD_ACCESS_TOKEN ||
         !!nxJson.nxCloudAccessToken ||
@@ -17,12 +16,3 @@ function getNxCloudUrl(nxJson) {
         throw new Error('nx-cloud runner not found in nx.json');
     return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
 }
-function getNxCloudToken(nxJson) {
-    const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
-    if (!cloudRunner &&
-        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
-        throw new Error('nx-cloud runner not found in nx.json');
-    return (process.env.NX_CLOUD_ACCESS_TOKEN ??
-        cloudRunner?.options.accessToken ??
-        nxJson.nxCloudAccessToken);
-}

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

@@ -1,3 +1,4 @@
+import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectConfiguration, ProjectMetadata, TargetConfiguration } from '../config/workspace-json-project-json';
 import { PackageManagerCommands } from './package-manager';
 export interface NxProjectPackageJsonConfiguration extends Partial<ProjectConfiguration> {
@@ -69,7 +70,7 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
 export declare function buildTargetFromScript(script: string, scripts: Record<string, string>, packageManagerCommand: PackageManagerCommands): TargetConfiguration;
 export declare function getMetadataFromPackageJson(packageJson: PackageJson): ProjectMetadata;
 export declare function getTagsFromPackageJson(packageJson: PackageJson): string[];
-export declare function readTargetsFromPackageJson(packageJson: PackageJson): Record<string, TargetConfiguration<any>>;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/utils/package-json.js

@@ -77,7 +77,7 @@ function getTagsFromPackageJson(packageJson) {
     }
     return tags;
 }
-function readTargetsFromPackageJson(packageJson) {
+function readTargetsFromPackageJson(packageJson, nxJson) {
     const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
@@ -92,12 +92,23 @@ function readTargetsFromPackageJson(packageJson) {
      * Add implicit nx-release-publish target for all package.json files that are
      * not marked as `"private": true` to allow for lightweight configuration for
      * package based repos.
+     *
+     * Any targetDefaults for the nx-release-publish target set by the user should
+     * be merged with the implicit target.
      */
     if (!isPrivate && !res['nx-release-publish']) {
+        const nxReleasePublishTargetDefaults = nxJson?.targetDefaults?.['nx-release-publish'] ?? {};
         res['nx-release-publish'] = {
-            dependsOn: ['^nx-release-publish'],
             executor: '@nx/js:release-publish',
-            options: {},
+            ...nxReleasePublishTargetDefaults,
+            dependsOn: [
+                // For maximum correctness, projects should only ever be published once their dependencies are successfully published
+                '^nx-release-publish',
+                ...(nxReleasePublishTargetDefaults.dependsOn ?? []),
+            ],
+            options: {
+                ...(nxReleasePublishTargetDefaults.options ?? {}),
+            },
         };
     }
     return res;

package/src/utils/params.d.ts

@@ -79,7 +79,6 @@ export type Options = {
     '--'?: Unmatched[];
     [k: string]: string | number | boolean | string[] | Unmatched[] | undefined;
 };
-export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<number>;
 export declare function convertToCamelCase(parsed: {
     [k: string]: any;
 }, schema: Schema): Options;

package/src/utils/params.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaError = void 0;
-exports.handleErrors = handleErrors;
 exports.convertToCamelCase = convertToCamelCase;
 exports.coerceTypesInOptions = coerceTypesInOptions;
 exports.convertAliases = convertAliases;
@@ -15,55 +14,6 @@ exports.warnDeprecations = warnDeprecations;
 exports.convertSmartDefaultsIntoNamedParams = convertSmartDefaultsIntoNamedParams;
 exports.getPromptsForSchema = getPromptsForSchema;
 const logger_1 = require("./logger");
-const output_1 = require("./output");
-const client_1 = require("../daemon/client/client");
-async function handleErrors(isVerbose, fn) {
-    try {
-        const result = await fn();
-        if (typeof result === 'number') {
-            return result;
-        }
-        return 0;
-    }
-    catch (err) {
-        err ||= new Error('Unknown error caught');
-        if (err.constructor.name === 'UnsuccessfulWorkflowExecution') {
-            logger_1.logger.error('The generator workflow failed. See above.');
-        }
-        else if (err.name === 'ProjectGraphError') {
-            const projectGraphError = err;
-            let title = projectGraphError.message;
-            if (isVerbose) {
-                title += ' See errors below.';
-            }
-            const bodyLines = isVerbose
-                ? [projectGraphError.stack]
-                : ['Pass --verbose to see the stacktraces.'];
-            output_1.output.error({
-                title,
-                bodyLines: bodyLines,
-            });
-        }
-        else {
-            const lines = (err.message ? err.message : err.toString()).split('\n');
-            const bodyLines = lines.slice(1);
-            if (err.stack && !isVerbose) {
-                bodyLines.push('Pass --verbose to see the stacktrace.');
-            }
-            output_1.output.error({
-                title: lines[0],
-                bodyLines,
-            });
-            if (err.stack && isVerbose) {
-                logger_1.logger.info(err.stack);
-            }
-        }
-        if (client_1.daemonClient.enabled()) {
-            client_1.daemonClient.reset();
-        }
-        return 1;
-    }
-}
 function camelCase(input) {
     if (input.indexOf('-') > 1) {
         return input

package/src/utils/plugins/plugin-capabilities.js

@@ -41,10 +41,13 @@ async function getPluginCapabilities(workspaceRoot, pluginName, projects, includ
             projectGraphExtension: pluginModule &&
                 ('processProjectGraph' in pluginModule ||
                     'createNodes' in pluginModule ||
+                    'createNodesV2' in pluginModule ||
+                    'createMetadata' in pluginModule ||
                     'createDependencies' in pluginModule),
             projectInference: pluginModule &&
                 ('projectFilePatterns' in pluginModule ||
-                    'createNodes' in pluginModule),
+                    'createNodes' in pluginModule ||
+                    'createNodesV2' in pluginModule),
         };
     }
     catch {

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 {};