nx 20.2.2 → 20.3.0-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.2.2",
+  "version": "20.3.0-beta.1",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -58,6 +58,7 @@
     "npm-run-path": "^4.0.1",
     "open": "^8.4.0",
     "ora": "5.3.0",
+    "resolve.exports": "2.0.3",
     "semver": "^7.5.3",
     "string-width": "^4.2.3",
     "tar-stream": "~2.2.0",
@@ -81,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.2.2",
-    "@nx/nx-darwin-x64": "20.2.2",
-    "@nx/nx-freebsd-x64": "20.2.2",
-    "@nx/nx-linux-arm-gnueabihf": "20.2.2",
-    "@nx/nx-linux-arm64-gnu": "20.2.2",
-    "@nx/nx-linux-arm64-musl": "20.2.2",
-    "@nx/nx-linux-x64-gnu": "20.2.2",
-    "@nx/nx-linux-x64-musl": "20.2.2",
-    "@nx/nx-win32-arm64-msvc": "20.2.2",
-    "@nx/nx-win32-x64-msvc": "20.2.2"
+    "@nx/nx-darwin-arm64": "20.3.0-beta.1",
+    "@nx/nx-darwin-x64": "20.3.0-beta.1",
+    "@nx/nx-freebsd-x64": "20.3.0-beta.1",
+    "@nx/nx-linux-arm-gnueabihf": "20.3.0-beta.1",
+    "@nx/nx-linux-arm64-gnu": "20.3.0-beta.1",
+    "@nx/nx-linux-arm64-musl": "20.3.0-beta.1",
+    "@nx/nx-linux-x64-gnu": "20.3.0-beta.1",
+    "@nx/nx-linux-x64-musl": "20.3.0-beta.1",
+    "@nx/nx-win32-arm64-msvc": "20.3.0-beta.1",
+    "@nx/nx-win32-x64-msvc": "20.3.0-beta.1"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -121,6 +122,7 @@
       "@nx/rollup",
       "@nx/remix",
       "@nx/rspack",
+      "@nx/rsbuild",
       "@nx/storybook",
       "@nx/vite",
       "@nx/vue",

package/src/adapter/ngcli-adapter.js

@@ -796,7 +796,7 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
                 builderName,
                 description: executorConfig.description,
                 optionSchema: builderInfo.schema,
-                import: (0, schema_utils_1.resolveImplementation)(executorConfig.implementation, (0, path_1.dirname)(executorsFilePath)),
+                import: (0, schema_utils_1.resolveImplementation)(executorConfig.implementation, (0, path_1.dirname)(executorsFilePath), packageName, this.projects),
             };
         }
         readExecutorsJson(nodeModule, builder, extraRequirePaths = []) {
@@ -825,14 +825,14 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
             try {
                 const { executorsFilePath, executorConfig, isNgCompat } = this.readExecutorsJson(nodeModule, executor);
                 const executorsDir = (0, path_1.dirname)(executorsFilePath);
-                const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir);
+                const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir, nodeModule, this.projects);
                 const schema = (0, executor_utils_1.normalizeExecutorSchema)((0, fileutils_1.readJsonFile)(schemaPath));
-                const implementationFactory = this.getImplementationFactory(executorConfig.implementation, executorsDir);
+                const implementationFactory = this.getImplementationFactory(executorConfig.implementation, executorsDir, nodeModule);
                 const batchImplementationFactory = executorConfig.batchImplementation
-                    ? this.getImplementationFactory(executorConfig.batchImplementation, executorsDir)
+                    ? this.getImplementationFactory(executorConfig.batchImplementation, executorsDir, nodeModule)
                     : null;
                 const hasherFactory = executorConfig.hasher
-                    ? this.getImplementationFactory(executorConfig.hasher, executorsDir)
+                    ? this.getImplementationFactory(executorConfig.hasher, executorsDir, nodeModule)
                     : null;
                 return {
                     schema,
@@ -846,8 +846,8 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
                 throw new Error(`Unable to resolve ${nodeModule}:${executor}.\n${e.message}`);
             }
         }
-        getImplementationFactory(implementation, executorsDir) {
-            return (0, schema_utils_1.getImplementationFactory)(implementation, executorsDir);
+        getImplementationFactory(implementation, executorsDir, packageName) {
+            return (0, schema_utils_1.getImplementationFactory)(implementation, executorsDir, packageName, this.projects);
         }
     }
     return new WrappedWorkspaceNodeModulesArchitectHost(workspace, root, projects);

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/generate/generator-utils.js

@@ -13,14 +13,14 @@ function getGeneratorInformation(collectionName, generatorName, root, projects)
         const generatorConfig = generatorsJson.generators?.[normalizedGeneratorName] ||
             generatorsJson.schematics?.[normalizedGeneratorName];
         const isNgCompat = !generatorsJson.generators?.[normalizedGeneratorName];
-        const schemaPath = (0, schema_utils_1.resolveSchema)(generatorConfig.schema, generatorsDir);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(generatorConfig.schema, generatorsDir, collectionName, projects);
         const schema = (0, fileutils_1.readJsonFile)(schemaPath);
         if (!schema.properties || typeof schema.properties !== 'object') {
             schema.properties = {};
         }
         generatorConfig.implementation =
             generatorConfig.implementation || generatorConfig.factory;
-        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(generatorConfig.implementation, generatorsDir);
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(generatorConfig.implementation, generatorsDir, collectionName, projects);
         const normalizedGeneratorConfiguration = {
             ...generatorConfig,
             aliases: generatorConfig.aliases ?? [],

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');
@@ -128,6 +113,7 @@ const npmPackageToPluginMap = {
     nuxt: '@nx/nuxt',
     'react-native': '@nx/react-native',
     '@remix-run/dev': '@nx/remix',
+    '@rsbuild/core': '@nx/rsbuild',
 };
 async function detectPlugins(nxJson, interactive, includeAngularCli) {
     let files = ['package.json'].concat((0, workspace_context_1.globWithWorkspaceContextSync)(process.cwd(), ['**/*/package.json']));

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

@@ -29,14 +29,14 @@ function getExecutorInformation(nodeModule, executor, root, projects) {
             return cachedExecutorInformation[key];
         const { executorsFilePath, executorConfig, isNgCompat } = readExecutorJson(nodeModule, executor, root, projects);
         const executorsDir = (0, path_1.dirname)(executorsFilePath);
-        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir, nodeModule, projects);
         const schema = normalizeExecutorSchema((0, fileutils_1.readJsonFile)(schemaPath));
-        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir);
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir, nodeModule, projects);
         const batchImplementationFactory = executorConfig.batchImplementation
-            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir)
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir, nodeModule, projects)
             : null;
         const hasherFactory = executorConfig.hasher
-            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir)
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir, nodeModule, projects)
             : null;
         const res = {
             schema,