nx 20.3.0-canary.20241214-4cd640a → 20.3.0-canary.20241217-ee4de0b

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.3.0-canary.20241214-4cd640a",
+  "version": "20.3.0-canary.20241217-ee4de0b",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -82,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-darwin-x64": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-freebsd-x64": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-linux-arm-gnueabihf": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-linux-arm64-gnu": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-linux-arm64-musl": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-linux-x64-gnu": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-linux-x64-musl": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-win32-arm64-msvc": "20.3.0-canary.20241214-4cd640a",
-    "@nx/nx-win32-x64-msvc": "20.3.0-canary.20241214-4cd640a"
+    "@nx/nx-darwin-arm64": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-darwin-x64": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-freebsd-x64": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-linux-arm-gnueabihf": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-linux-arm64-gnu": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-linux-arm64-musl": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-linux-x64-gnu": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-linux-x64-musl": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-win32-arm64-msvc": "20.3.0-canary.20241217-ee4de0b",
+    "@nx/nx-win32-x64-msvc": "20.3.0-canary.20241217-ee4de0b"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -5,7 +5,7 @@ exports.addHandler = addHandler;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const ora = require("ora");
-const angular_json_1 = require("../../adapter/angular-json");
+const yargsParser = require("yargs-parser");
 const nx_json_1 = require("../../config/nx-json");
 const child_process_2 = require("../../utils/child-process");
 const fileutils_1 = require("../../utils/fileutils");
@@ -13,11 +13,11 @@ const logger_1 = require("../../utils/logger");
 const output_1 = require("../../utils/output");
 const package_manager_1 = require("../../utils/package-manager");
 const handle_errors_1 = require("../../utils/handle-errors");
-const plugins_1 = require("../../utils/plugins");
 const versions_1 = require("../../utils/versions");
 const workspace_root_1 = require("../../utils/workspace-root");
 const add_nx_scripts_1 = require("../init/implementation/dot-nx/add-nx-scripts");
 const semver_1 = require("semver");
+const configure_plugins_1 = require("../init/configure-plugins");
 function addHandler(options) {
     return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
         output_1.output.addNewline();
@@ -79,63 +79,39 @@ async function installPackage(pkgName, version, nxJson) {
     spinner.succeed();
 }
 async function initializePlugin(pkgName, options, nxJson) {
-    const capabilities = await (0, plugins_1.getPluginCapabilities)(workspace_root_1.workspaceRoot, pkgName, {});
-    const generators = capabilities?.generators;
-    if (!generators) {
-        output_1.output.log({
-            title: `No generators found in ${pkgName}. Skipping initialization.`,
-        });
-        return;
-    }
-    const initGenerator = findInitGenerator(generators);
-    if (!initGenerator) {
-        output_1.output.log({
-            title: `No "init" generator found in ${pkgName}. Skipping initialization.`,
-        });
-        return;
+    const parsedCommandArgs = yargsParser(options.__overrides_unparsed__, {
+        configuration: {
+            'parse-numbers': false,
+            'parse-positional-numbers': false,
+            'dot-notation': false,
+            'camel-case-expansion': false,
+        },
+    });
+    if (exports.coreNxPluginVersions.has(pkgName)) {
+        parsedCommandArgs.keepExistingVersions = true;
+        if (options.updatePackageScripts ||
+            (options.updatePackageScripts === undefined &&
+                nxJson.useInferencePlugins !== false &&
+                process.env.NX_ADD_PLUGINS !== 'false')) {
+            parsedCommandArgs.updatePackageScripts = true;
+        }
     }
     const spinner = ora(`Initializing ${pkgName}...`);
     spinner.start();
     try {
-        const args = [];
-        if (exports.coreNxPluginVersions.has(pkgName)) {
-            args.push(`--keepExistingVersions`);
-            if (options.updatePackageScripts ||
-                (options.updatePackageScripts === undefined &&
-                    nxJson.useInferencePlugins !== false &&
-                    process.env.NX_ADD_PLUGINS !== 'false')) {
-                args.push(`--updatePackageScripts`);
-            }
-        }
-        if (options.__overrides_unparsed__.length) {
-            args.push(...options.__overrides_unparsed__);
-        }
-        (0, child_process_2.runNxSync)(`g ${pkgName}:${initGenerator} ${args.join(' ')}`, {
-            stdio: [0, 1, 2],
-        });
+        await (0, configure_plugins_1.installPlugin)(pkgName, workspace_root_1.workspaceRoot, options.verbose, parsedCommandArgs);
     }
     catch (e) {
         spinner.fail();
         output_1.output.addNewline();
-        logger_1.logger.error(e);
         output_1.output.error({
-            title: `Failed to initialize ${pkgName}. Please check the error above for more details.`,
+            title: `Failed to initialize ${pkgName}`,
+            bodyLines: (0, configure_plugins_1.getFailedToInstallPluginErrorMessages)(e),
         });
         process.exit(1);
     }
     spinner.succeed();
 }
-function findInitGenerator(generators) {
-    if (generators['init']) {
-        return 'init';
-    }
-    const angularPluginInstalled = (0, angular_json_1.isAngularPluginInstalled)();
-    if (angularPluginInstalled && generators['ng-add']) {
-        return 'ng-add';
-    }
-    return Object.keys(generators).find((name) => generators[name].aliases?.includes('init') ||
-        (angularPluginInstalled && generators[name].aliases?.includes('ng-add')));
-}
 function parsePackageSpecifier(packageSpecifier) {
     const i = packageSpecifier.lastIndexOf('@');
     if (i <= 0) {

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

@@ -19,12 +19,12 @@ const utils_1 = require("../init/implementation/utils");
 const command_line_utils_1 = require("../../utils/command-line-utils");
 const prepare_source_repo_1 = require("./utils/prepare-source-repo");
 const merge_remote_source_1 = require("./utils/merge-remote-source");
-const needs_install_1 = require("./utils/needs-install");
 const minimatch_1 = require("minimatch");
+const configure_plugins_1 = require("../init/configure-plugins");
 const importRemoteName = '__tmp_nx_import__';
 async function importHandler(options) {
     process.env.NX_RUNNING_NX_IMPORT = 'true';
-    let { sourceRepository, ref, source, destination } = options;
+    let { sourceRepository, ref, source, destination, verbose } = options;
     const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
     if (await destinationGitClient.hasUncommittedChanges()) {
         throw new Error(`You have uncommitted changes in the destination repository. Commit or revert the changes and try again.`);
@@ -141,7 +141,6 @@ async function importHandler(options) {
         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 sourceIsNxWorkspace = (0, node_fs_1.existsSync)((0, path_1.join)(sourceGitClient.root, 'nx.json'));
     const relativeDestination = (0, path_1.relative)(destinationGitClient.root, absDestination);
     await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRepository);
@@ -165,40 +164,18 @@ async function importHandler(options) {
         });
     }
     await handleMissingWorkspacesEntry(packageManager, pmc, relativeDestination, destinationGitClient);
-    // If install fails, we should continue since the errors could be resolved later.
-    let installFailed = false;
-    if (plugins.length > 0) {
-        try {
-            output_1.output.log({ title: 'Installing Plugins' });
-            (0, init_v2_1.installPlugins)(workspace_root_1.workspaceRoot, plugins, pmc, updatePackageScripts);
-            await destinationGitClient.amendCommit();
-        }
-        catch (e) {
-            installFailed = true;
-            output_1.output.error({
-                title: `Install failed: ${e.message || 'Unknown error'}`,
-                bodyLines: [e.stack],
-            });
-        }
-    }
-    else if (await (0, needs_install_1.needsInstall)(packageManager, originalPackageWorkspaces)) {
-        try {
-            output_1.output.log({
-                title: 'Installing dependencies for imported code',
-            });
-            (0, utils_1.runInstall)(workspace_root_1.workspaceRoot, (0, package_manager_1.getPackageManagerCommand)(packageManager));
-            await destinationGitClient.amendCommit();
-        }
-        catch (e) {
-            installFailed = true;
-            output_1.output.error({
-                title: `Install failed: ${e.message || 'Unknown error'}`,
-                bodyLines: [e.stack],
-            });
+    let installed = await runInstallDestinationRepo(packageManager, destinationGitClient);
+    if (installed && plugins.length > 0) {
+        installed = await runPluginsInstall(plugins, pmc, destinationGitClient);
+        if (installed) {
+            const { succeededPlugins } = await (0, configure_plugins_1.configurePlugins)(plugins, updatePackageScripts, pmc, workspace_root_1.workspaceRoot, verbose);
+            if (succeededPlugins.length > 0) {
+                await destinationGitClient.amendCommit();
+            }
         }
     }
     console.log(await destinationGitClient.showStat());
-    if (installFailed) {
+    if (installed === false) {
         const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
         output_1.output.warn({
             title: `The import was successful, but the install failed`,
@@ -258,6 +235,55 @@ async function createTemporaryRemote(destinationGitClient, sourceRemoteUrl, remo
     await destinationGitClient.fetch(remoteName);
 }
 /**
+ * Run install for the imported code and plugins
+ * @returns true if the install failed
+ */
+async function runInstallDestinationRepo(packageManager, destinationGitClient) {
+    let installed = true;
+    try {
+        output_1.output.log({
+            title: 'Installing dependencies for imported code',
+        });
+        (0, utils_1.runInstall)(workspace_root_1.workspaceRoot, (0, package_manager_1.getPackageManagerCommand)(packageManager));
+        await destinationGitClient.amendCommit();
+    }
+    catch (e) {
+        installed = false;
+        output_1.output.error({
+            title: `Install failed: ${e.message || 'Unknown error'}`,
+            bodyLines: [e.stack],
+        });
+    }
+    return installed;
+}
+async function runPluginsInstall(plugins, pmc, destinationGitClient) {
+    let installed = true;
+    output_1.output.log({ title: 'Installing Plugins' });
+    try {
+        (0, configure_plugins_1.runPackageManagerInstallPlugins)(workspace_root_1.workspaceRoot, pmc, plugins);
+        await destinationGitClient.amendCommit();
+    }
+    catch (e) {
+        installed = false;
+        output_1.output.error({
+            title: `Install failed: ${e.message || 'Unknown error'}`,
+            bodyLines: [
+                'The following plugins were not installed:',
+                ...plugins.map((p) => `- ${chalk.bold(p)}`),
+                e.stack,
+            ],
+        });
+        output_1.output.error({
+            title: `To install the plugins manually`,
+            bodyLines: [
+                'You may need to run commands to install the plugins:',
+                ...plugins.map((p) => `- ${chalk.bold(pmc.exec + ' nx add ' + p)}`),
+            ],
+        });
+    }
+    return installed;
+}
+/*
  * If the user imports a project that isn't in the workspaces entry, we should add that path to the workspaces entry.
  */
 async function handleMissingWorkspacesEntry(pm, pmc, pkgPath, destinationGitClient) {

package/src/command-line/init/configure-plugins.d.ts

@@ -0,0 +1,35 @@
+import { PackageManagerCommands } from '../../utils/package-manager';
+export declare function runPackageManagerInstallPlugins(repoRoot: string, pmc: PackageManagerCommands, plugins: string[]): void;
+/**
+ * Installs a plugin by running its init generator. It will change the file system tree passed in.
+ * @param plugin The name of the plugin to install
+ * @param repoRoot repo root
+ * @param verbose verbose
+ * @param options options passed to init generator
+ * @returns void
+ */
+export declare function installPlugin(plugin: string, repoRoot: string, verbose: boolean, options: {
+    [k: string]: any;
+}): Promise<void>;
+/**
+ * Install plugins
+ * Get the implementation of the plugin's init generator and run it
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+export declare function installPlugins(plugins: string[], updatePackageScripts: boolean, repoRoot?: string, verbose?: boolean): Promise<{
+    succeededPlugins: string[];
+    failedPlugins: {
+        [plugin: string]: Error;
+    };
+}>;
+/**
+ * Configures plugins, installs them, and outputs the results
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+export declare function configurePlugins(plugins: string[], updatePackageScripts: boolean, pmc: PackageManagerCommands, repoRoot?: string, verbose?: boolean): Promise<{
+    succeededPlugins: string[];
+    failedPlugins: {
+        [plugin: string]: Error;
+    };
+}>;
+export declare function getFailedToInstallPluginErrorMessages(e: any): string[];

package/src/command-line/init/configure-plugins.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPackageManagerInstallPlugins = runPackageManagerInstallPlugins;
+exports.installPlugin = installPlugin;
+exports.installPlugins = installPlugins;
+exports.configurePlugins = configurePlugins;
+exports.getFailedToInstallPluginErrorMessages = getFailedToInstallPluginErrorMessages;
+const createSpinner = require("ora");
+const chalk_1 = require("chalk");
+const package_manager_1 = require("../../utils/package-manager");
+const output_1 = require("../../utils/output");
+const tree_1 = require("../../generators/tree");
+const generator_utils_1 = require("../generate/generator-utils");
+const workspace_root_1 = require("../../utils/workspace-root");
+const utils_1 = require("./implementation/utils");
+const plugins_1 = require("../../utils/plugins");
+const angular_json_1 = require("../../adapter/angular-json");
+const error_types_1 = require("../../project-graph/error-types");
+function runPackageManagerInstallPlugins(repoRoot, pmc = (0, package_manager_1.getPackageManagerCommand)(), plugins) {
+    if (plugins.length === 0) {
+        return;
+    }
+    (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
+    (0, utils_1.runInstall)(repoRoot, pmc);
+}
+/**
+ * Installs a plugin by running its init generator. It will change the file system tree passed in.
+ * @param plugin The name of the plugin to install
+ * @param repoRoot repo root
+ * @param verbose verbose
+ * @param options options passed to init generator
+ * @returns void
+ */
+async function installPlugin(plugin, repoRoot = workspace_root_1.workspaceRoot, verbose = false, options) {
+    const host = new tree_1.FsTree(repoRoot, verbose, `install ${plugin}`);
+    const capabilities = await (0, plugins_1.getPluginCapabilities)(repoRoot, plugin, {});
+    const generators = capabilities?.generators;
+    if (!generators) {
+        throw new Error(`No generators found in ${plugin}.`);
+    }
+    const initGenerator = findInitGenerator(generators);
+    if (!initGenerator) {
+        output_1.output.log({
+            title: `No "init" generator found in ${plugin}. Skipping initialization.`,
+        });
+        return;
+    }
+    const { implementationFactory } = (0, generator_utils_1.getGeneratorInformation)(plugin, initGenerator, repoRoot, {});
+    const implementation = implementationFactory();
+    const task = await implementation(host, options);
+    (0, tree_1.flushChanges)(repoRoot, host.listChanges());
+    if (task) {
+        await task();
+    }
+}
+/**
+ * Install plugins
+ * Get the implementation of the plugin's init generator and run it
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+async function installPlugins(plugins, updatePackageScripts, repoRoot = workspace_root_1.workspaceRoot, verbose = false) {
+    if (plugins.length === 0) {
+        return {
+            succeededPlugins: [],
+            failedPlugins: {},
+        };
+    }
+    const spinner = createSpinner();
+    let succeededPlugins = [];
+    const failedPlugins = {};
+    for (const plugin of plugins) {
+        try {
+            spinner.start('Installing plugin ' + plugin);
+            await installPlugin(plugin, repoRoot, verbose, {
+                keepExistingVersions: true,
+                updatePackageScripts,
+                addPlugin: true,
+                skipFormat: false,
+                skipPackageJson: false,
+            });
+            succeededPlugins.push(plugin);
+            spinner.succeed('Installed plugin ' + plugin);
+        }
+        catch (e) {
+            failedPlugins[plugin] = e;
+            spinner.fail('Failed to install plugin ' + plugin);
+        }
+    }
+    return {
+        succeededPlugins,
+        failedPlugins,
+    };
+}
+/**
+ * Configures plugins, installs them, and outputs the results
+ * @returns a list of succeeded plugins and a map of failed plugins to errors
+ */
+async function configurePlugins(plugins, updatePackageScripts, pmc, repoRoot = workspace_root_1.workspaceRoot, verbose = false) {
+    if (plugins.length === 0) {
+        return {
+            succeededPlugins: [],
+            failedPlugins: {},
+        };
+    }
+    output_1.output.log({ title: '🔨 Configuring plugins' });
+    let { succeededPlugins, failedPlugins } = await installPlugins(plugins, updatePackageScripts, repoRoot, verbose);
+    if (succeededPlugins.length > 0) {
+        output_1.output.success({
+            title: 'Installed Plugins',
+            bodyLines: succeededPlugins.map((p) => `- ${(0, chalk_1.bold)(p)}`),
+        });
+    }
+    if (Object.keys(failedPlugins).length > 0) {
+        output_1.output.error({
+            title: `Failed to install plugins`,
+            bodyLines: [
+                'The following plugins were not installed:',
+                ...Object.keys(failedPlugins).map((p) => `- ${(0, chalk_1.bold)(p)}`),
+            ],
+        });
+        Object.entries(failedPlugins).forEach(([plugin, error]) => {
+            output_1.output.error({
+                title: `Failed to install ${plugin}`,
+                bodyLines: getFailedToInstallPluginErrorMessages(error),
+            });
+        });
+        output_1.output.error({
+            title: `To install the plugins manually`,
+            bodyLines: [
+                'You may need to run commands to install the plugins:',
+                ...Object.keys(failedPlugins).map((p) => `- ${(0, chalk_1.bold)(pmc.exec + ' nx add ' + p)}`),
+            ],
+        });
+    }
+    return { succeededPlugins, failedPlugins };
+}
+function findInitGenerator(generators) {
+    if (generators['init']) {
+        return 'init';
+    }
+    const angularPluginInstalled = (0, angular_json_1.isAngularPluginInstalled)();
+    if (angularPluginInstalled && generators['ng-add']) {
+        return 'ng-add';
+    }
+    return Object.keys(generators).find((name) => generators[name].aliases?.includes('init') ||
+        (angularPluginInstalled && generators[name].aliases?.includes('ng-add')));
+}
+function getFailedToInstallPluginErrorMessages(e) {
+    const errorBodyLines = [];
+    if ((0, error_types_1.isProjectConfigurationsError)(e) && e.errors.length > 0) {
+        for (const error of e.errors) {
+            if ((0, error_types_1.isAggregateCreateNodesError)(error)) {
+                const innerErrors = error.errors;
+                for (const [file, e] of innerErrors) {
+                    if (file) {
+                        errorBodyLines.push(`  - ${(0, chalk_1.bold)(file)}: ${e.message}`);
+                    }
+                    else {
+                        errorBodyLines.push(`  - ${e.message}`);
+                    }
+                    if (e.stack) {
+                        const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
+                        errorBodyLines.push(innerStackTrace);
+                    }
+                }
+            }
+            else if (!(0, error_types_1.isProjectsWithNoNameError)(error)) {
+                // swallow ProjectsWithNameError
+                if (error.message) {
+                    errorBodyLines.push(`  - ${error.message}`);
+                }
+                if (error.stack) {
+                    const innerStackTrace = '    ' + error.stack.split('\n')?.join('\n    ');
+                    errorBodyLines.push(innerStackTrace);
+                }
+            }
+        }
+    }
+    else {
+        if (e.message) {
+            errorBodyLines.push(`  - ${e.message}`);
+        }
+        if (e.stack) {
+            const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
+            errorBodyLines.push(innerStackTrace);
+        }
+    }
+    return errorBodyLines;
+}

package/src/command-line/init/init-v2.d.ts

@@ -1,12 +1,11 @@
-import { PackageManagerCommands } from '../../utils/package-manager';
 import { NxJsonConfiguration } from '../../config/nx-json';
 export interface InitArgs {
     interactive: boolean;
     nxCloud?: boolean;
     useDotNxInstallation?: boolean;
     integrated?: boolean;
+    verbose?: boolean;
 }
-export declare function installPlugins(repoRoot: string, plugins: string[], pmc: PackageManagerCommands, updatePackageScripts: boolean): void;
 export declare function initHandler(options: InitArgs): Promise<void>;
 export declare function detectPlugins(nxJson: NxJsonConfiguration, interactive: boolean, includeAngularCli?: boolean): Promise<{
     plugins: string[];

package/src/command-line/init/init-v2.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.installPlugins = installPlugins;
 exports.initHandler = initHandler;
 exports.detectPlugins = detectPlugins;
 const fs_1 = require("fs");
@@ -13,7 +12,6 @@ const fileutils_1 = require("../../utils/fileutils");
 const versions_1 = require("../../utils/versions");
 const utils_1 = require("./implementation/utils");
 const enquirer_1 = require("enquirer");
-const child_process_2 = require("child_process");
 const angular_1 = require("./implementation/angular");
 const workspace_context_1 = require("../../utils/workspace-context");
 const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
@@ -21,21 +19,7 @@ const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
 const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
 const nx_json_1 = require("../../config/nx-json");
 const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
-function installPlugins(repoRoot, plugins, pmc, updatePackageScripts) {
-    if (plugins.length === 0) {
-        return;
-    }
-    (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
-    (0, utils_1.runInstall)(repoRoot, pmc);
-    output_1.output.log({ title: '🔨 Configuring plugins' });
-    for (const plugin of plugins) {
-        (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${updatePackageScripts ? '--updatePackageScripts' : ''}`, {
-            stdio: [0, 1, 2],
-            cwd: repoRoot,
-            windowsHide: false,
-        });
-    }
-}
+const configure_plugins_1 = require("./configure-plugins");
 async function initHandler(options) {
     process.env.NX_RUNNING_NX_INIT = 'true';
     const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
@@ -98,7 +82,8 @@ async function initHandler(options) {
     output_1.output.log({ title: '🧐 Checking dependencies' });
     const { plugins, updatePackageScripts } = await detectPlugins(nxJson, options.interactive);
     output_1.output.log({ title: '📦 Installing Nx' });
-    installPlugins(repoRoot, plugins, pmc, updatePackageScripts);
+    (0, configure_plugins_1.runPackageManagerInstallPlugins)(repoRoot, pmc, plugins);
+    await (0, configure_plugins_1.configurePlugins)(plugins, updatePackageScripts, pmc, repoRoot, options.verbose);
     if (useNxCloud) {
         output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
         await (0, utils_1.initCloud)('nx-init');

package/src/daemon/client/client.js

@@ -30,6 +30,7 @@ const get_sync_generator_changes_1 = require("../message-types/get-sync-generato
 const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
 const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
+const delayed_spinner_1 = require("../../utils/delayed-spinner");
 const DAEMON_ENV_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -113,6 +114,11 @@ class DaemonClient {
         return this.sendToDaemonViaQueue({ type: 'REQUEST_SHUTDOWN' });
     }
     async getProjectGraphAndSourceMaps() {
+        let spinner;
+        if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+            // If the graph takes a while to load, we want to show a spinner.
+            spinner = new delayed_spinner_1.DelayedSpinner('Calculating the project graph on the Nx Daemon', 500).scheduleMessageUpdate('Calculating the project graph on the Nx Daemon is taking longer than expected. Re-run with NX_DAEMON=false to see more details.', 30_000);
+        }
         try {
             const response = await this.sendToDaemonViaQueue({
                 type: 'REQUEST_PROJECT_GRAPH',
@@ -130,6 +136,9 @@ class DaemonClient {
                 throw e;
             }
         }
+        finally {
+            spinner?.cleanup();
+        }
     }
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });

package/src/project-graph/build-project-graph.js

@@ -18,6 +18,7 @@ const configuration_1 = require("../config/configuration");
 const fs_1 = require("fs");
 const error_types_1 = require("./error-types");
 const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const delayed_spinner_1 = require("../utils/delayed-spinner");
 let storedFileMap = null;
 let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
@@ -186,11 +187,39 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
     const createDependencyPlugins = plugins.filter((plugin) => plugin.createDependencies);
     perf_hooks_1.performance.mark('createDependencies:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            return `Creating project graph dependencies with ${inProgressPlugins.keys()[0]}`;
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            return [
+                `Creating project graph dependencies with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n');
+        }
+        else {
+            return `Creating project graph dependencies with ${inProgressPlugins.size} plugins`;
+        }
+    }
+    if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+        spinner = new delayed_spinner_1.DelayedSpinner(`Creating project graph dependencies with ${plugins.length} plugins`);
+    }
     await Promise.all(createDependencyPlugins.map(async (plugin) => {
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
+        inProgressPlugins.add(plugin.name);
         try {
-            const dependencies = await plugin.createDependencies({
+            const dependencies = await plugin
+                .createDependencies({
                 ...context,
+            })
+                .finally(() => {
+                inProgressPlugins.delete(plugin.name);
+                updateSpinner();
             });
             for (const dep of dependencies) {
                 builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
@@ -206,6 +235,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
     }));
     perf_hooks_1.performance.mark('createDependencies:end');
     perf_hooks_1.performance.measure(`createDependencies`, `createDependencies:start`, `createDependencies:end`);
+    spinner?.cleanup();
     const graphWithDeps = builder.getUpdatedProjectGraph();
     const { errors: metadataErrors, graph: updatedGraph } = await applyProjectMetadata(graphWithDeps, plugins, {
         nxJsonConfiguration: context.nxJsonConfiguration,
@@ -232,9 +262,32 @@ async function applyProjectMetadata(graph, plugins, context, sourceMap) {
     const results = [];
     const errors = [];
     perf_hooks_1.performance.mark('createMetadata:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            return `Creating project metadata with ${inProgressPlugins.keys()[0]}`;
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            return [
+                `Creating project metadata with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n');
+        }
+        else {
+            return `Creating project metadata with ${inProgressPlugins.size} plugins`;
+        }
+    }
+    if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+        spinner = new delayed_spinner_1.DelayedSpinner(`Creating project metadata with ${plugins.length} plugins`);
+    }
     const promises = plugins.map(async (plugin) => {
         if (plugin.createMetadata) {
             perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
+            inProgressPlugins.add(plugin.name);
             try {
                 const metadata = await plugin.createMetadata(graph, context);
                 results.push({ metadata, pluginName: plugin.name });
@@ -243,12 +296,15 @@ async function applyProjectMetadata(graph, plugins, context, sourceMap) {
                 errors.push(new error_types_1.CreateMetadataError(e, plugin.name));
             }
             finally {
+                inProgressPlugins.delete(plugin.name);
+                updateSpinner();
                 perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - end`);
                 perf_hooks_1.performance.measure(`${plugin.name}:createMetadata`, `${plugin.name}:createMetadata - start`, `${plugin.name}:createMetadata - end`);
             }
         }
     });
     await Promise.all(promises);
+    spinner?.cleanup();
     for (const { metadata: projectsMetadata, pluginName } of results) {
         for (const project in projectsMetadata) {
             const projectConfiguration = graph.nodes[project]?.data;

package/src/project-graph/plugins/internal-api.d.ts

@@ -1,14 +1,15 @@
 import { PluginConfiguration } from '../../config/nx-json';
-import { CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2 } from './public-api';
+import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, ProjectsMetadata } from './public-api';
 import { ProjectGraph } from '../../config/project-graph';
+import { RawProjectGraphDependency } from '../project-graph-builder';
 export declare class LoadedNxPlugin {
     readonly name: string;
     readonly createNodes?: [
         filePattern: string,
         fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
     ];
-    readonly createDependencies?: (context: CreateDependenciesContext) => ReturnType<CreateDependencies>;
-    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => ReturnType<CreateMetadata>;
+    readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
+    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
     readonly options?: unknown;
     readonly include?: string[];
     readonly exclude?: string[];

package/src/project-graph/plugins/internal-api.js

@@ -57,10 +57,10 @@ class LoadedNxPlugin {
             };
         }
         if (plugin.createDependencies) {
-            this.createDependencies = (context) => plugin.createDependencies(this.options, context);
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
         }
         if (plugin.createMetadata) {
-            this.createMetadata = (graph, context) => plugin.createMetadata(graph, this.options, context);
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
         }
     }
 }

package/src/project-graph/plugins/isolation/messaging.d.ts

@@ -68,7 +68,7 @@ export interface PluginCreateMetadataMessage {
 export interface PluginCreateDependenciesResult {
     type: 'createDependenciesResult';
     payload: {
-        dependencies: ReturnType<LoadedNxPlugin['createDependencies']>;
+        dependencies: Awaited<ReturnType<LoadedNxPlugin['createDependencies']>>;
         success: true;
         tx: string;
     } | {
@@ -80,7 +80,7 @@ export interface PluginCreateDependenciesResult {
 export interface PluginCreateMetadataResult {
     type: 'createMetadataResult';
     payload: {
-        metadata: ReturnType<LoadedNxPlugin['createMetadata']>;
+        metadata: Awaited<ReturnType<LoadedNxPlugin['createMetadata']>>;
         success: true;
         tx: string;
     } | {

package/src/project-graph/utils/project-configuration-utils.js

@@ -20,6 +20,7 @@ const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const error_types_1 = require("../error-types");
 const globs_1 = require("../../utils/globs");
+const delayed_spinner_1 = require("../../utils/delayed-spinner");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -224,6 +225,28 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
 async function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
 plugins) {
     perf_hooks_1.performance.mark('build-project-configs:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            return `Creating project graph nodes with ${inProgressPlugins.keys()[0]}`;
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            return [
+                `Creating project graph nodes with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n');
+        }
+        else {
+            return `Creating project graph nodes with ${inProgressPlugins.size} plugins`;
+        }
+    }
+    if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+        spinner = new delayed_spinner_1.DelayedSpinner(`Creating project graph nodes with ${plugins.length} plugins`);
+    }
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
@@ -233,10 +256,12 @@ plugins) {
             continue;
         }
         const matchingConfigFiles = findMatchingConfigFiles(projectFiles, pattern, include, exclude);
+        inProgressPlugins.add(pluginName);
         let r = createNodes(matchingConfigFiles, {
             nxJsonConfiguration: nxJson,
             workspaceRoot: root,
-        }).catch((e) => {
+        })
+            .catch((e) => {
             const errorBodyLines = [
                 `An error occurred while processing files for the ${pluginName} plugin.`,
             ];
@@ -263,10 +288,15 @@ plugins) {
             errors.push(error);
             // The plugin didn't return partial results, so we return an empty array.
             return error.partialResults.map((r) => [pluginName, r[0], r[1]]);
+        })
+            .finally(() => {
+            inProgressPlugins.delete(pluginName);
+            updateSpinner();
         });
         results.push(r);
     }
     return Promise.all(results).then((results) => {
+        spinner?.cleanup();
         const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');

package/src/tasks-runner/forked-process-task-runner.js

@@ -220,24 +220,46 @@ class ForkedProcessTaskRunner {
                     }
                 }
                 let outWithErr = [];
+                let exitCode;
+                let stdoutHasEnded = false;
+                let stderrHasEnded = false;
+                let processHasExited = false;
+                const handleProcessEnd = () => {
+                    // ensure process has exited and both stdout and stderr have ended before we pass along the logs
+                    // if we only wait for the process to exit, we might miss some logs as stdout and stderr might still be streaming
+                    if (stdoutHasEnded && stderrHasEnded && processHasExited) {
+                        // we didn't print any output as we were running the command
+                        // print all the collected output|
+                        const terminalOutput = outWithErr.join('');
+                        const code = exitCode;
+                        if (!streamOutput) {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                        }
+                        this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
+                        res({ code, terminalOutput });
+                    }
+                };
                 p.stdout.on('data', (chunk) => {
                     outWithErr.push(chunk.toString());
                 });
+                p.stdout.on('end', () => {
+                    stdoutHasEnded = true;
+                    handleProcessEnd();
+                });
                 p.stderr.on('data', (chunk) => {
                     outWithErr.push(chunk.toString());
                 });
+                p.stderr.on('end', () => {
+                    stderrHasEnded = true;
+                    handleProcessEnd();
+                });
                 p.on('exit', (code, signal) => {
                     this.processes.delete(p);
                     if (code === null)
                         code = (0, exit_codes_1.signalToCode)(signal);
-                    // we didn't print any output as we were running the command
-                    // print all the collected output|
-                    const terminalOutput = outWithErr.join('');
-                    if (!streamOutput) {
-                        this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
-                    }
-                    this.writeTerminalOutput(temporaryOutputPath, terminalOutput);
-                    res({ code, terminalOutput });
+                    exitCode = code;
+                    processHasExited = true;
+                    handleProcessEnd();
                 });
             }
             catch (e) {

package/src/utils/delayed-spinner.d.ts

@@ -0,0 +1,40 @@
+import * as ora from 'ora';
+/**
+ * A class that allows to delay the creation of a spinner, as well
+ * as schedule updates to the message of the spinner. Useful for
+ * scenarios where one wants to only show a spinner if an operation
+ * takes longer than a certain amount of time.
+ */
+export declare class DelayedSpinner {
+    spinner: ora.Ora;
+    timeouts: NodeJS.Timeout[];
+    initial: number;
+    /**
+     * Constructs a new {@link DelayedSpinner} instance.
+     *
+     * @param message The message to display in the spinner
+     * @param ms The number of milliseconds to wait before creating the spinner
+     */
+    constructor(message: string, ms?: number);
+    /**
+     * Sets the message to display in the spinner.
+     *
+     * @param message The message to display in the spinner
+     * @returns The {@link DelayedSpinner} instance
+     */
+    setMessage(message: string): this;
+    /**
+     * Schedules an update to the message of the spinner. Useful for
+     * changing the message after a certain amount of time has passed.
+     *
+     * @param message The message to display in the spinner
+     * @param delay How long to wait before updating the message
+     * @returns The {@link DelayedSpinner} instance
+     */
+    scheduleMessageUpdate(message: string, delay: number): this;
+    /**
+     * Stops the spinner and cleans up any scheduled timeouts.
+     */
+    cleanup(): void;
+}
+export declare const SHOULD_SHOW_SPINNERS: boolean;

package/src/utils/delayed-spinner.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SHOULD_SHOW_SPINNERS = exports.DelayedSpinner = void 0;
+const ora = require("ora");
+/**
+ * A class that allows to delay the creation of a spinner, as well
+ * as schedule updates to the message of the spinner. Useful for
+ * scenarios where one wants to only show a spinner if an operation
+ * takes longer than a certain amount of time.
+ */
+class DelayedSpinner {
+    /**
+     * Constructs a new {@link DelayedSpinner} instance.
+     *
+     * @param message The message to display in the spinner
+     * @param ms The number of milliseconds to wait before creating the spinner
+     */
+    constructor(message, ms = 500) {
+        this.timeouts = [];
+        this.initial = Date.now();
+        this.timeouts.push(setTimeout(() => {
+            this.spinner = ora(message);
+        }, ms).unref());
+    }
+    /**
+     * Sets the message to display in the spinner.
+     *
+     * @param message The message to display in the spinner
+     * @returns The {@link DelayedSpinner} instance
+     */
+    setMessage(message) {
+        this.spinner.text = message;
+        return this;
+    }
+    /**
+     * Schedules an update to the message of the spinner. Useful for
+     * changing the message after a certain amount of time has passed.
+     *
+     * @param message The message to display in the spinner
+     * @param delay How long to wait before updating the message
+     * @returns The {@link DelayedSpinner} instance
+     */
+    scheduleMessageUpdate(message, delay) {
+        this.timeouts.push(setTimeout(() => {
+            this.spinner.text = message;
+        }, delay).unref());
+        return this;
+    }
+    /**
+     * Stops the spinner and cleans up any scheduled timeouts.
+     */
+    cleanup() {
+        this.spinner?.stop();
+        this.timeouts.forEach((t) => clearTimeout(t));
+    }
+}
+exports.DelayedSpinner = DelayedSpinner;
+exports.SHOULD_SHOW_SPINNERS = process.stdout.isTTY;

package/src/command-line/import/utils/needs-install.d.ts

@@ -1,3 +0,0 @@
-import { PackageManager } from '../../../utils/package-manager';
-export declare function getPackagesInPackageManagerWorkspace(packageManager: PackageManager): Promise<Set<string>>;
-export declare function needsInstall(packageManager: PackageManager, originalPackagesInPackageManagerWorkspaces: Set<string>): Promise<boolean>;

package/src/command-line/import/utils/needs-install.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackagesInPackageManagerWorkspace = getPackagesInPackageManagerWorkspace;
-exports.needsInstall = needsInstall;
-const package_manager_1 = require("../../../utils/package-manager");
-const workspace_root_1 = require("../../../utils/workspace-root");
-const package_json_1 = require("../../../plugins/package-json");
-const workspace_context_1 = require("../../../utils/workspace-context");
-async function getPackagesInPackageManagerWorkspace(packageManager) {
-    if (!(0, package_manager_1.isWorkspacesEnabled)(packageManager, workspace_root_1.workspaceRoot)) {
-        return new Set();
-    }
-    const patterns = (0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(workspace_root_1.workspaceRoot);
-    return new Set(await (0, workspace_context_1.globWithWorkspaceContext)(workspace_root_1.workspaceRoot, patterns));
-}
-async function needsInstall(packageManager, originalPackagesInPackageManagerWorkspaces) {
-    if (!(0, package_manager_1.isWorkspacesEnabled)(packageManager, workspace_root_1.workspaceRoot)) {
-        return false;
-    }
-    const updatedPackagesInPackageManagerWorkspaces = await getPackagesInPackageManagerWorkspace(packageManager);
-    if (updatedPackagesInPackageManagerWorkspaces.size !==
-        originalPackagesInPackageManagerWorkspaces.size) {
-        return true;
-    }
-    for (const pkg of updatedPackagesInPackageManagerWorkspaces) {
-        if (!originalPackagesInPackageManagerWorkspaces.has(pkg)) {
-            return true;
-        }
-    }
-    return false;
-}