nx 19.7.2 → 19.7.3

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

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