nx 20.4.2 → 20.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.4.2",
+  "version": "20.4.4",
   "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.4.2",
-    "@nx/nx-darwin-x64": "20.4.2",
-    "@nx/nx-freebsd-x64": "20.4.2",
-    "@nx/nx-linux-arm-gnueabihf": "20.4.2",
-    "@nx/nx-linux-arm64-gnu": "20.4.2",
-    "@nx/nx-linux-arm64-musl": "20.4.2",
-    "@nx/nx-linux-x64-gnu": "20.4.2",
-    "@nx/nx-linux-x64-musl": "20.4.2",
-    "@nx/nx-win32-arm64-msvc": "20.4.2",
-    "@nx/nx-win32-x64-msvc": "20.4.2"
+    "@nx/nx-darwin-arm64": "20.4.4",
+    "@nx/nx-darwin-x64": "20.4.4",
+    "@nx/nx-freebsd-x64": "20.4.4",
+    "@nx/nx-linux-arm-gnueabihf": "20.4.4",
+    "@nx/nx-linux-arm64-gnu": "20.4.4",
+    "@nx/nx-linux-arm64-musl": "20.4.4",
+    "@nx/nx-linux-x64-gnu": "20.4.4",
+    "@nx/nx-linux-x64-musl": "20.4.4",
+    "@nx/nx-win32-arm64-msvc": "20.4.4",
+    "@nx/nx-win32-x64-msvc": "20.4.4"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/adapter/compat.d.ts

@@ -1,2 +1,2 @@
 export declare const allowedProjectExtensions: readonly ["tags", "implicitDependencies", "configFilePath", "$schema", "generators", "namedInputs", "name", "files", "root", "sourceRoot", "projectType", "release", "includedScripts", "metadata"];
-export declare const allowedWorkspaceExtensions: readonly ["implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudId", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud", "sync", "useLegacyCache"];
+export declare const allowedWorkspaceExtensions: readonly ["$schema", "implicitDependencies", "affected", "defaultBase", "tasksRunnerOptions", "workspaceLayout", "plugins", "targetDefaults", "files", "generators", "namedInputs", "extends", "cli", "pluginsConfig", "defaultProject", "installation", "release", "nxCloudAccessToken", "nxCloudId", "nxCloudUrl", "nxCloudEncryptionKey", "parallel", "cacheDirectory", "useDaemonProcess", "useInferencePlugins", "neverConnectToCloud", "sync", "useLegacyCache"];

package/src/adapter/compat.js

@@ -37,6 +37,7 @@ exports.allowedProjectExtensions = [
 // There are some props in here (root) that angular already knows about,
 // but it doesn't hurt to have them in here as well to help static analysis.
 exports.allowedWorkspaceExtensions = [
+    '$schema',
     'implicitDependencies',
     'affected',
     'defaultBase',

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

@@ -5,7 +5,6 @@ exports.addHandler = addHandler;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const ora = require("ora");
-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");
@@ -79,27 +78,18 @@ async function installPackage(pkgName, version, nxJson) {
     spinner.succeed();
 }
 async function initializePlugin(pkgName, options, nxJson) {
-    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 ||
+    let updatePackageScripts = false;
+    if (exports.coreNxPluginVersions.has(pkgName) &&
+        (options.updatePackageScripts ||
             (options.updatePackageScripts === undefined &&
                 nxJson.useInferencePlugins !== false &&
-                process.env.NX_ADD_PLUGINS !== 'false')) {
-            parsedCommandArgs.updatePackageScripts = true;
-        }
+                process.env.NX_ADD_PLUGINS !== 'false'))) {
+        updatePackageScripts = true;
     }
     const spinner = ora(`Initializing ${pkgName}...`);
     spinner.start();
     try {
-        await (0, configure_plugins_1.installPlugin)(pkgName, workspace_root_1.workspaceRoot, options.verbose, parsedCommandArgs);
+        await (0, configure_plugins_1.installPlugin)(pkgName, workspace_root_1.workspaceRoot, updatePackageScripts, options.verbose);
     }
     catch (e) {
         spinner.fail();

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

@@ -7,14 +7,21 @@ exports.yargsInitCommand = {
     describe: 'Adds Nx to any type of workspace. It installs nx, creates an nx.json configuration file and optionally sets up remote caching. For more info, check https://nx.dev/recipes/adopting-nx.',
     builder: (yargs) => withInitOptions(yargs),
     handler: async (args) => {
-        const useV2 = await isInitV2();
-        if (useV2) {
-            await require('./init-v2').initHandler(args);
+        try {
+            const useV2 = await isInitV2();
+            if (useV2) {
+                await require('./init-v2').initHandler(args);
+            }
+            else {
+                await require('./init-v1').initHandler(args);
+            }
+            process.exit(0);
         }
-        else {
-            await require('./init-v1').initHandler(args);
+        catch {
+            // Ensure the cursor is always restored just in case the user has bailed during interactive prompts
+            process.stdout.write('\x1b[?25h');
+            process.exit(1);
         }
-        process.exit(0);
     },
 };
 async function isInitV2() {

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

@@ -4,19 +4,18 @@ export declare function runPackageManagerInstallPlugins(repoRoot: string, pmc: P
  * 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
+ * @param pmc package manager commands
+ * @param updatePackageScripts whether to update package scripts
+ * @param verbose whether to run in verbose mode
  * @returns void
  */
-export declare function installPlugin(plugin: string, repoRoot: string, verbose: boolean, options: {
-    [k: string]: any;
-}): Promise<void>;
+export declare function installPlugin(plugin: string, repoRoot?: string, updatePackageScripts?: boolean, verbose?: boolean, pmc?: PackageManagerCommands): 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<{
+export declare function installPlugins(plugins: string[], updatePackageScripts: boolean, pmc: PackageManagerCommands, repoRoot?: string, verbose?: boolean): Promise<{
     succeededPlugins: string[];
     failedPlugins: {
         [plugin: string]: Error;

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

@@ -7,10 +7,9 @@ exports.configurePlugins = configurePlugins;
 exports.getFailedToInstallPluginErrorMessages = getFailedToInstallPluginErrorMessages;
 const createSpinner = require("ora");
 const chalk_1 = require("chalk");
+const child_process_1 = require("child_process");
 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");
@@ -27,12 +26,12 @@ function runPackageManagerInstallPlugins(repoRoot, pmc = (0, package_manager_1.g
  * 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
+ * @param pmc package manager commands
+ * @param updatePackageScripts whether to update package scripts
+ * @param verbose whether to run in verbose mode
  * @returns void
  */
-async function installPlugin(plugin, repoRoot = workspace_root_1.workspaceRoot, verbose = false, options) {
-    const host = new tree_1.FsTree(repoRoot, verbose, `install ${plugin}`);
+async function installPlugin(plugin, repoRoot = workspace_root_1.workspaceRoot, updatePackageScripts = false, verbose = false, pmc = (0, package_manager_1.getPackageManagerCommand)()) {
     const capabilities = await (0, plugins_1.getPluginCapabilities)(repoRoot, plugin, {});
     const generators = capabilities?.generators;
     if (!generators) {
@@ -45,20 +44,18 @@ async function installPlugin(plugin, repoRoot = workspace_root_1.workspaceRoot,
         });
         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();
-    }
+    (0, child_process_1.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${updatePackageScripts ? '--updatePackageScripts' : ''} ${verbose ? '--verbose' : ''}`, {
+        stdio: [0, 1, 2],
+        cwd: repoRoot,
+        windowsHide: false,
+    });
 }
 /**
  * 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) {
+async function installPlugins(plugins, updatePackageScripts, pmc, repoRoot = workspace_root_1.workspaceRoot, verbose = false) {
     if (plugins.length === 0) {
         return {
             succeededPlugins: [],
@@ -71,13 +68,7 @@ async function installPlugins(plugins, updatePackageScripts, repoRoot = workspac
     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,
-            });
+            await installPlugin(plugin, repoRoot, updatePackageScripts, verbose, pmc);
             succeededPlugins.push(plugin);
             spinner.succeed('Installed plugin ' + plugin);
         }
@@ -103,7 +94,7 @@ async function configurePlugins(plugins, updatePackageScripts, pmc, repoRoot = w
         };
     }
     output_1.output.log({ title: '🔨 Configuring plugins' });
-    let { succeededPlugins, failedPlugins } = await installPlugins(plugins, updatePackageScripts, repoRoot, verbose);
+    let { succeededPlugins, failedPlugins } = await installPlugins(plugins, updatePackageScripts, pmc, repoRoot, verbose);
     if (succeededPlugins.length > 0) {
         output_1.output.success({
             title: 'Installed Plugins',

package/src/command-line/init/implementation/add-nx-to-turborepo.d.ts

@@ -0,0 +1,4 @@
+import { InitArgs } from '../init-v1';
+type Options = Pick<InitArgs, 'nxCloud' | 'interactive'>;
+export declare function addNxToTurborepo(_options: Options): Promise<void>;
+export {};

package/src/command-line/init/implementation/add-nx-to-turborepo.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNxToTurborepo = addNxToTurborepo;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fileutils_1 = require("../../../utils/fileutils");
+const output_1 = require("../../../utils/output");
+const package_manager_1 = require("../../../utils/package-manager");
+const utils_1 = require("./utils");
+async function addNxToTurborepo(_options) {
+    const repoRoot = process.cwd();
+    output_1.output.log({
+        title: 'Initializing Nx based on your old Turborepo configuration',
+    });
+    output_1.output.log({
+        title: '💡 Did you know?',
+        bodyLines: [
+            '- Turborepo requires you to maintain all your common scripts like "build", "lint", "test" in all your packages, as well as their applicable cache inputs and outputs.',
+            `- Nx is extensible and has plugins for the tools you use to infer all of this for you purely based on that tool's configuration file within your packages.`,
+            '',
+            '  - E.g. the `@nx/vite` plugin will infer the "build" script based on the existence of a vite.config.js file.',
+            '  - Therefore with zero package level config, `nx build my-app` knows to run the `vite build` CLI directly, with all Nx cache inputs and outputs automatically inferred.',
+            '',
+            `NOTE: None of your existing package.json scripts will be modified as part of this initialization process, you can already use them as-is with Nx, but you can learn more about the benefits of Nx's inferred tasks at https://nx.dev/concepts/inferred-tasks`,
+        ],
+    });
+    let nxJson = (0, utils_1.createNxJsonFromTurboJson)((0, fileutils_1.readJsonFile)('turbo.json'));
+    const nxJsonPath = (0, node_path_1.join)(repoRoot, 'nx.json');
+    // Turborepo workspaces usually have prettier installed, so try and match the formatting before writing the file
+    try {
+        const prettier = await Promise.resolve().then(() => require('prettier'));
+        const config = await prettier.resolveConfig(repoRoot);
+        (0, node_fs_1.writeFileSync)(nxJsonPath, 
+        // @ts-ignore - Always await prettier.format, in modern versions it's async
+        await prettier.format(JSON.stringify(nxJson, null, 2), {
+            ...(config ?? {}),
+            parser: 'json',
+        }));
+    }
+    catch (err) {
+        // Apply fallback JSON write
+        (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
+    }
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    (0, utils_1.addDepsToPackageJson)(repoRoot);
+    output_1.output.log({ title: '📦 Installing dependencies' });
+    (0, utils_1.runInstall)(repoRoot, pmc);
+}

package/src/command-line/init/implementation/deduce-default-base.d.ts

@@ -0,0 +1 @@
+export declare function deduceDefaultBase(): string;

package/src/command-line/init/implementation/deduce-default-base.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduceDefaultBase = deduceDefaultBase;
+const node_child_process_1 = require("node:child_process");
+const default_base_1 = require("../../../utils/default-base");
+function deduceDefaultBase() {
+    try {
+        (0, node_child_process_1.execSync)(`git rev-parse --verify main`, {
+            stdio: ['ignore', 'ignore', 'ignore'],
+            windowsHide: false,
+        });
+        return 'main';
+    }
+    catch {
+        try {
+            (0, node_child_process_1.execSync)(`git rev-parse --verify dev`, {
+                stdio: ['ignore', 'ignore', 'ignore'],
+                windowsHide: false,
+            });
+            return 'dev';
+        }
+        catch {
+            try {
+                (0, node_child_process_1.execSync)(`git rev-parse --verify develop`, {
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                    windowsHide: false,
+                });
+                return 'develop';
+            }
+            catch {
+                try {
+                    (0, node_child_process_1.execSync)(`git rev-parse --verify next`, {
+                        stdio: ['ignore', 'ignore', 'ignore'],
+                        windowsHide: false,
+                    });
+                    return 'next';
+                }
+                catch {
+                    try {
+                        (0, node_child_process_1.execSync)(`git rev-parse --verify master`, {
+                            stdio: ['ignore', 'ignore', 'ignore'],
+                            windowsHide: false,
+                        });
+                        return 'master';
+                    }
+                    catch {
+                        return (0, default_base_1.deduceDefaultBase)();
+                    }
+                }
+            }
+        }
+    }
+}

package/src/command-line/init/implementation/utils.d.ts

@@ -1,12 +1,14 @@
+import { NxJsonConfiguration } from '../../../config/nx-json';
 import { PackageJson } from '../../../utils/package-json';
 import { PackageManagerCommands } from '../../../utils/package-manager';
 export declare function createNxJsonFile(repoRoot: string, topologicalTargets: string[], cacheableOperations: string[], scriptOutputs: {
     [name: string]: string;
 }): void;
+export declare function createNxJsonFromTurboJson(turboJson: Record<string, any>): NxJsonConfiguration;
 export declare function addDepsToPackageJson(repoRoot: string, additionalPackages?: string[]): void;
 export declare function updateGitIgnore(root: string): void;
 export declare function runInstall(repoRoot: string, pmc?: PackageManagerCommands): void;
-export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-cra' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo'): Promise<void>;
+export declare function initCloud(installationSource: 'nx-init' | 'nx-init-angular' | 'nx-init-cra' | 'nx-init-monorepo' | 'nx-init-nest' | 'nx-init-npm-repo' | 'nx-init-turborepo'): Promise<void>;
 export declare function addVsCodeRecommendedExtensions(repoRoot: string, extensions: string[]): void;
 export declare function markRootPackageJsonAsNxProjectLegacy(repoRoot: string, cacheableScripts: string[], pmc: PackageManagerCommands): void;
 export declare function markPackageJsonAsNxProject(packageJsonPath: string): void;

package/src/command-line/init/implementation/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNxJsonFile = createNxJsonFile;
+exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
 exports.addDepsToPackageJson = addDepsToPackageJson;
 exports.updateGitIgnore = updateGitIgnore;
 exports.runInstall = runInstall;
@@ -21,7 +22,7 @@ const fs_1 = require("fs");
 const connect_to_nx_cloud_1 = require("../../../nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud");
 const url_shorten_1 = require("../../../nx-cloud/utilities/url-shorten");
 const connect_to_nx_cloud_2 = require("../../connect/connect-to-nx-cloud");
-const default_base_1 = require("../../../utils/default-base");
+const deduce_default_base_1 = require("./deduce-default-base");
 function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scriptOutputs) {
     const nxJsonPath = (0, path_2.joinPathFragments)(repoRoot, 'nx.json');
     let nxJson = {};
@@ -53,56 +54,104 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     if (Object.keys(nxJson.targetDefaults).length === 0) {
         delete nxJson.targetDefaults;
     }
-    nxJson.defaultBase ??= deduceDefaultBase();
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
     (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
 }
-function deduceDefaultBase() {
-    try {
-        (0, child_process_1.execSync)(`git rev-parse --verify main`, {
-            stdio: ['ignore', 'ignore', 'ignore'],
-            windowsHide: false,
-        });
-        return 'main';
-    }
-    catch {
-        try {
-            (0, child_process_1.execSync)(`git rev-parse --verify dev`, {
-                stdio: ['ignore', 'ignore', 'ignore'],
-                windowsHide: false,
-            });
-            return 'dev';
+function createNxJsonFromTurboJson(turboJson) {
+    const nxJson = {
+        $schema: './node_modules/nx/schemas/nx-schema.json',
+    };
+    // Handle global dependencies
+    if (turboJson.globalDependencies?.length > 0) {
+        nxJson.namedInputs = {
+            sharedGlobals: turboJson.globalDependencies.map((dep) => `{workspaceRoot}/${dep}`),
+            default: ['{projectRoot}/**/*', 'sharedGlobals'],
+        };
+    }
+    // Handle global env vars
+    if (turboJson.globalEnv?.length > 0) {
+        nxJson.namedInputs = nxJson.namedInputs || {};
+        nxJson.namedInputs.sharedGlobals = nxJson.namedInputs.sharedGlobals || [];
+        nxJson.namedInputs.sharedGlobals.push(...turboJson.globalEnv.map((env) => ({ env })));
+        nxJson.namedInputs.default = nxJson.namedInputs.default || [];
+        if (!nxJson.namedInputs.default.includes('{projectRoot}/**/*')) {
+            nxJson.namedInputs.default.push('{projectRoot}/**/*');
         }
-        catch {
-            try {
-                (0, child_process_1.execSync)(`git rev-parse --verify develop`, {
-                    stdio: ['ignore', 'ignore', 'ignore'],
-                    windowsHide: false,
-                });
-                return 'develop';
+        if (!nxJson.namedInputs.default.includes('sharedGlobals')) {
+            nxJson.namedInputs.default.push('sharedGlobals');
+        }
+    }
+    // Handle task configurations
+    if (turboJson.tasks) {
+        nxJson.targetDefaults = {};
+        for (const [taskName, taskConfig] of Object.entries(turboJson.tasks)) {
+            // Skip project-specific tasks (containing #)
+            if (taskName.includes('#'))
+                continue;
+            const config = taskConfig;
+            nxJson.targetDefaults[taskName] = {};
+            // Handle dependsOn
+            if (config.dependsOn?.length > 0) {
+                nxJson.targetDefaults[taskName].dependsOn = config.dependsOn;
             }
-            catch {
-                try {
-                    (0, child_process_1.execSync)(`git rev-parse --verify next`, {
-                        stdio: ['ignore', 'ignore', 'ignore'],
-                        windowsHide: false,
-                    });
-                    return 'next';
-                }
-                catch {
-                    try {
-                        (0, child_process_1.execSync)(`git rev-parse --verify master`, {
-                            stdio: ['ignore', 'ignore', 'ignore'],
-                            windowsHide: false,
-                        });
-                        return 'master';
+            // Handle inputs
+            if (config.inputs?.length > 0) {
+                nxJson.targetDefaults[taskName].inputs = config.inputs
+                    .map((input) => {
+                    if (input === '$TURBO_DEFAULT$') {
+                        return '{projectRoot}/**/*';
                     }
-                    catch {
-                        return (0, default_base_1.deduceDefaultBase)();
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                })
+                    .map((input) => {
+                    // Don't add projectRoot if it's already there or if it's an env var
+                    if (input.startsWith('{projectRoot}/') ||
+                        input.startsWith('{env.') ||
+                        input.startsWith('$'))
+                        return input;
+                    return `{projectRoot}/${input}`;
+                });
+            }
+            // Handle outputs
+            if (config.outputs?.length > 0) {
+                nxJson.targetDefaults[taskName].outputs = config.outputs.map((output) => {
+                    // Don't add projectRoot if it's already there
+                    if (output.startsWith('{projectRoot}/'))
+                        return output;
+                    // Handle negated patterns by adding projectRoot after the !
+                    if (output.startsWith('!')) {
+                        return `!{projectRoot}/${output.slice(1)}`;
                     }
-                }
+                    return `{projectRoot}/${output}`;
+                });
             }
+            // Handle cache setting - true by default in Turbo
+            nxJson.targetDefaults[taskName].cache = config.cache !== false;
         }
     }
+    /**
+     * The fact that cacheDir was in use suggests the user had a reason for deviating from the default.
+     * We can't know what that reason was, nor if it would still be applicable in Nx, but we can at least
+     * improve discoverability of the relevant Nx option by explicitly including it with its default value.
+     */
+    if (turboJson.cacheDir) {
+        nxJson.cacheDirectory = '.nx/cache';
+    }
+    const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
+    // Do not add defaultBase if it is inferred to be the Nx default value of main
+    if (defaultBase !== 'main') {
+        nxJson.defaultBase ??= defaultBase;
+    }
+    return nxJson;
 }
 function addDepsToPackageJson(repoRoot, additionalPackages) {
     const path = (0, path_2.joinPathFragments)(repoRoot, `package.json`);

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

@@ -3,23 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.initHandler = initHandler;
 exports.detectPlugins = detectPlugins;
 const fs_1 = require("fs");
+const enquirer_1 = require("enquirer");
 const semver_1 = require("semver");
-const output_1 = require("../../utils/output");
-const package_manager_1 = require("../../utils/package-manager");
-const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const nx_json_1 = require("../../config/nx-json");
 const child_process_1 = require("../../utils/child-process");
 const fileutils_1 = require("../../utils/fileutils");
+const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
 const versions_1 = require("../../utils/versions");
-const utils_1 = require("./implementation/utils");
-const enquirer_1 = require("enquirer");
-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");
-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");
 const configure_plugins_1 = require("./configure-plugins");
+const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
+const add_nx_to_turborepo_1 = require("./implementation/add-nx-to-turborepo");
+const angular_1 = require("./implementation/angular");
+const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const utils_1 = require("./implementation/utils");
 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');
@@ -57,7 +58,29 @@ async function initHandler(options) {
         return;
     }
     const packageJson = (0, fileutils_1.readJsonFile)('package.json');
-    if ((0, utils_1.isMonorepo)(packageJson)) {
+    const _isTurborepo = (0, fs_1.existsSync)('turbo.json');
+    const _isMonorepo = (0, utils_1.isMonorepo)(packageJson);
+    const learnMoreLink = _isTurborepo
+        ? 'https://nx.dev/recipes/adopting-nx/from-turborepo'
+        : _isMonorepo
+            ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
+            : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
+    /**
+     * Turborepo users must have set up individual scripts already, and we keep the transition as minimal as possible.
+     * We log a message during the conversion process in addNxToTurborepo about how they can learn more about the power
+     * of Nx plugins and how it would allow them to infer all the relevant scripts automatically, including all cache
+     * inputs and outputs.
+     */
+    if (_isTurborepo) {
+        await (0, add_nx_to_turborepo_1.addNxToTurborepo)({
+            interactive: options.interactive,
+        });
+        (0, utils_1.printFinalMessage)({
+            learnMoreLink,
+        });
+        return;
+    }
+    if (_isMonorepo) {
         await (0, add_nx_to_monorepo_1.addNxToMonorepo)({
             interactive: options.interactive,
             nxCloud: false,
@@ -69,9 +92,6 @@ async function initHandler(options) {
             nxCloud: false,
         });
     }
-    const learnMoreLink = (0, utils_1.isMonorepo)(packageJson)
-        ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
-        : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
     const useNxCloud = options.nxCloud ??
         (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
     const repoRoot = process.cwd();

package/src/config/nx-json.d.ts

@@ -321,6 +321,7 @@ export interface NxSyncConfiguration {
  * @note: when adding properties here add them to `allowedWorkspaceExtensions` in adapter/compat.ts
  */
 export interface NxJsonConfiguration<T = '*' | string[]> {
+    $schema?: string;
     /**
      * Optional (additional) Nx.json configuration file which becomes a base for this one
      */

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

@@ -47,6 +47,7 @@ export declare class DaemonClient {
     recordOutputsHash(outputs: string[], hash: string): Promise<any>;
     outputsHashesMatch(outputs: string[], hash: string): Promise<any>;
     glob(globs: string[], exclude?: string[]): Promise<string[]>;
+    multiGlob(globs: string[], exclude?: string[]): Promise<string[][]>;
     getWorkspaceContextFileData(): Promise<FileData[]>;
     getWorkspaceFiles(projectRootMap: Record<string, string>): Promise<NxWorkspaceFiles>;
     getFilesInDirectory(dir: string): Promise<string[]>;

package/src/daemon/client/client.js

@@ -215,6 +215,14 @@ class DaemonClient {
         };
         return this.sendToDaemonViaQueue(message);
     }
+    multiGlob(globs, exclude) {
+        const message = {
+            type: 'MULTI_GLOB',
+            globs,
+            exclude,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     getWorkspaceContextFileData() {
         const message = {
             type: get_context_file_data_1.GET_CONTEXT_FILE_DATA,

package/src/daemon/message-types/glob.d.ts

@@ -5,3 +5,10 @@ export type HandleGlobMessage = {
     exclude?: string[];
 };
 export declare function isHandleGlobMessage(message: unknown): message is HandleGlobMessage;
+export declare const MULTI_GLOB: "MULTI_GLOB";
+export type HandleMultiGlobMessage = {
+    type: typeof MULTI_GLOB;
+    globs: string[];
+    exclude?: string[];
+};
+export declare function isHandleMultiGlobMessage(message: unknown): message is HandleMultiGlobMessage;

package/src/daemon/message-types/glob.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GLOB = void 0;
+exports.MULTI_GLOB = exports.GLOB = void 0;
 exports.isHandleGlobMessage = isHandleGlobMessage;
+exports.isHandleMultiGlobMessage = isHandleMultiGlobMessage;
 exports.GLOB = 'GLOB';
 function isHandleGlobMessage(message) {
     return (typeof message === 'object' &&
@@ -9,3 +10,10 @@ function isHandleGlobMessage(message) {
         'type' in message &&
         message['type'] === exports.GLOB);
 }
+exports.MULTI_GLOB = 'MULTI_GLOB';
+function isHandleMultiGlobMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.MULTI_GLOB);
+}

package/src/daemon/server/handle-glob.d.ts

@@ -1,2 +1,3 @@
 import { HandlerResult } from './server';
 export declare function handleGlob(globs: string[], exclude?: string[]): Promise<HandlerResult>;
+export declare function handleMultiGlob(globs: string[], exclude?: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-glob.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleGlob = handleGlob;
+exports.handleMultiGlob = handleMultiGlob;
 const workspace_root_1 = require("../../utils/workspace-root");
 const workspace_context_1 = require("../../utils/workspace-context");
 async function handleGlob(globs, exclude) {
@@ -10,3 +11,10 @@ async function handleGlob(globs, exclude) {
         description: 'handleGlob',
     };
 }
+async function handleMultiGlob(globs, exclude) {
+    const files = await (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspace_root_1.workspaceRoot, globs, exclude);
+    return {
+        response: JSON.stringify(files),
+        description: 'handleMultiGlob',
+    };
+}

package/src/daemon/server/server.js

@@ -129,6 +129,9 @@ async function handleMessage(socket, data) {
     else if ((0, glob_1.isHandleGlobMessage)(payload)) {
         await handleResult(socket, glob_1.GLOB, () => (0, handle_glob_1.handleGlob)(payload.globs, payload.exclude));
     }
+    else if ((0, glob_1.isHandleMultiGlobMessage)(payload)) {
+        await handleResult(socket, glob_1.MULTI_GLOB, () => (0, handle_glob_1.handleMultiGlob)(payload.globs, payload.exclude));
+    }
     else if ((0, get_nx_workspace_files_1.isHandleNxWorkspaceFilesMessage)(payload)) {
         await handleResult(socket, get_nx_workspace_files_1.GET_NX_WORKSPACE_FILES, () => (0, handle_nx_workspace_files_1.handleNxWorkspaceFiles)(payload.projectRootMap));
     }

package/src/native/index.d.ts

@@ -93,6 +93,13 @@ export declare class WorkspaceContext {
   constructor(workspaceRoot: string, cacheDir: string)
   getWorkspaceFiles(projectRootMap: Record<string, string>): NxWorkspaceFiles
   glob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<string>
+  /**
+   * Performs multiple glob pattern matches against workspace files in parallel
+   * @returns An array of arrays, where each inner array contains the file paths
+   * that matched the corresponding glob pattern in the input. The outer array maintains the same order
+   * as the input globs.
+   */
+  multiGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): Array<Array<string>>
   hashFilesMatchingGlob(globs: Array<string>, exclude?: Array<string> | undefined | null): string
   incrementalUpdate(updatedFiles: Array<string>, deletedFiles: Array<string>): Record<string, string>
   updateProjectFiles(projectRootMappings: ProjectRootMappings, projectFiles: ExternalObject<ProjectFiles>, globalFiles: ExternalObject<Array<FileData>>, updatedFiles: Record<string, string>, deletedFiles: Array<string>): UpdatedWorkspaceFiles

package/src/native/nx.wasi.cjs

@@ -119,13 +119,13 @@ function __napi_rs_initialize_modules(__napiInstance) {
   __napiInstance.exports['__napi_register__FileLock_struct_39']?.()
   __napiInstance.exports['__napi_register__FileLock_impl_41']?.()
   __napiInstance.exports['__napi_register__WorkspaceContext_struct_42']?.()
-  __napiInstance.exports['__napi_register__WorkspaceContext_impl_51']?.()
-  __napiInstance.exports['__napi_register__WorkspaceErrors_52']?.()
-  __napiInstance.exports['__napi_register__NxWorkspaceFiles_struct_53']?.()
-  __napiInstance.exports['__napi_register__NxWorkspaceFilesExternals_struct_54']?.()
-  __napiInstance.exports['__napi_register__UpdatedWorkspaceFiles_struct_55']?.()
-  __napiInstance.exports['__napi_register__FileMap_struct_56']?.()
-  __napiInstance.exports['__napi_register____test_only_transfer_file_map_57']?.()
+  __napiInstance.exports['__napi_register__WorkspaceContext_impl_52']?.()
+  __napiInstance.exports['__napi_register__WorkspaceErrors_53']?.()
+  __napiInstance.exports['__napi_register__NxWorkspaceFiles_struct_54']?.()
+  __napiInstance.exports['__napi_register__NxWorkspaceFilesExternals_struct_55']?.()
+  __napiInstance.exports['__napi_register__UpdatedWorkspaceFiles_struct_56']?.()
+  __napiInstance.exports['__napi_register__FileMap_struct_57']?.()
+  __napiInstance.exports['__napi_register____test_only_transfer_file_map_58']?.()
 }
 module.exports.FileLock = __napiModule.exports.FileLock
 module.exports.HashPlanner = __napiModule.exports.HashPlanner

package/src/project-graph/affected/locators/project-glob-changes.js

@@ -20,8 +20,8 @@ const getTouchedProjectsFromProjectGlobChanges = async (touchedFiles, projectGra
                 'package.json',
             ]);
         }
-        const plugins = await (0, get_plugins_1.getPlugins)();
-        return (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.configurationGlobs)(plugins));
+        const plugins = (await (0, get_plugins_1.getPlugins)()).filter((p) => !!p.createNodes);
+        return (0, globs_1.combineGlobPatterns)((0, retrieve_workspace_files_1.getGlobPatternsOfPlugins)(plugins));
     })();
     const touchedProjects = new Set();
     for (const touchedFile of touchedFiles) {

package/src/project-graph/error-types.js

@@ -216,7 +216,10 @@ class AggregateCreateNodesError extends Error {
 exports.AggregateCreateNodesError = AggregateCreateNodesError;
 function formatAggregateCreateNodesError(error, pluginName) {
     const errorBodyLines = [
-        `${error.errors.length > 1 ? `${error.errors.length} errors` : 'An error'} occurred while processing files for the ${pluginName} plugin.`,
+        `${error.errors.length > 1 ? `${error.errors.length} errors` : 'An error'} occurred while processing files for the ${pluginName} plugin${error.pluginIndex
+            ? ` (Defined at nx.json#plugins[${error.pluginIndex}])`
+            : ''}`,
+        `.`,
     ];
     const errorStackLines = [];
     const innerErrors = error.errors;

package/src/project-graph/plugins/get-plugins.js

@@ -108,12 +108,13 @@ async function loadSpecifiedNxPlugins(plugins, root = workspace_root_1.workspace
     plugins ??= [];
     const cleanupFunctions = [];
     const ret = [
-        await Promise.all(plugins.map(async (plugin) => {
+        await Promise.all(plugins.map(async (plugin, index) => {
             const pluginPath = typeof plugin === 'string' ? plugin : plugin.plugin;
             performance.mark(`Load Nx Plugin: ${pluginPath} - start`);
             const [loadedPluginPromise, cleanup] = await loadingMethod(plugin, root);
             cleanupFunctions.push(cleanup);
             const res = await loadedPluginPromise;
+            res.index = index;
             performance.mark(`Load Nx Plugin: ${pluginPath} - end`);
             performance.measure(`Load Nx Plugin: ${pluginPath}`, `Load Nx Plugin: ${pluginPath} - start`, `Load Nx Plugin: ${pluginPath} - end`);
             return res;

package/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -3,6 +3,7 @@ import type { PluginConfiguration } from '../../config/nx-json';
 import type { RawProjectGraphDependency } from '../project-graph-builder';
 import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
 export declare class LoadedNxPlugin {
+    index?: number;
     readonly name: string;
     readonly createNodes?: [
         filePattern: string,

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

@@ -280,7 +280,7 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
             handleProjectGraphError(opts, e);
         }
         finally {
-            lock.unlock();
+            lock?.unlock();
         }
     }
     else {

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -35,7 +35,7 @@ export type ConfigurationResult = {
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
  */
-export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
+export declare function createProjectConfigurationsWithPlugins(root: string, nxJson: NxJsonConfiguration, projectFiles: string[][], // making this parameter allows devkit to pick up newly created projects
 plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
 export declare function findMatchingConfigFiles(projectFiles: string[], pattern: string, include: string[], exclude: string[]): string[];
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 exports.mergeMetadata = mergeMetadata;
-exports.createProjectConfigurations = createProjectConfigurations;
+exports.createProjectConfigurationsWithPlugins = createProjectConfigurationsWithPlugins;
 exports.findMatchingConfigFiles = findMatchingConfigFiles;
 exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
 exports.validateProject = validateProject;
@@ -222,7 +222,7 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
  * @param workspaceFiles A list of non-ignored workspace files
  * @param plugins The plugins that should be used to infer project configuration
  */
-async function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
+async function createProjectConfigurationsWithPlugins(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;
@@ -248,12 +248,12 @@ plugins) {
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const [index, { createNodes: createNodesTuple, include, exclude, name: pluginName },] of plugins.entries()) {
+    for (const [index, { index: pluginIndex, createNodes: createNodesTuple, include, exclude, name: pluginName, },] of plugins.entries()) {
         const [pattern, createNodes] = createNodesTuple ?? [];
         if (!pattern) {
             continue;
         }
-        const matchingConfigFiles = findMatchingConfigFiles(projectFiles, pattern, include, exclude);
+        const matchingConfigFiles = findMatchingConfigFiles(projectFiles[index], pattern, include, exclude);
         inProgressPlugins.add(pluginName);
         let r = createNodes(matchingConfigFiles, {
             nxJsonConfiguration: nxJson,
@@ -265,8 +265,10 @@ plugins) {
                     e
                 : // This represents a single plugin erroring out with a hard error.
                     new error_types_1.AggregateCreateNodesError([[null, e]], []);
+            if (pluginIndex) {
+                error.pluginIndex = pluginIndex;
+            }
             (0, error_types_1.formatAggregateCreateNodesError)(error, pluginName);
-            error.pluginIndex = index;
             // This represents a single plugin erroring out with a hard error.
             errors.push(error);
             // The plugin didn't return partial results, so we return an empty array.
@@ -289,7 +291,7 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles,
+                matchingProjectFiles: projectFiles.flat(),
             };
         }
         else {
@@ -298,7 +300,7 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles,
+                matchingProjectFiles: projectFiles.flat(),
             });
         }
     });
@@ -309,7 +311,7 @@ function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
     const externalNodes = {};
     const configurationSourceMaps = {};
     for (const result of results.flat()) {
-        const [pluginName, file, nodes, index] = result;
+        const [pluginName, file, nodes, pluginIndex] = result;
         const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
         const sourceInfo = [file, pluginName];
         for (const node in projectNodes) {
@@ -329,7 +331,7 @@ function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
                     file,
                     pluginName,
                     error,
-                    pluginIndex: index,
+                    pluginIndex,
                 }));
             }
         }

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -23,4 +23,4 @@ export declare function retrieveProjectConfigurations(plugins: LoadedNxPlugin[],
 export declare function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot: string, nxJson: NxJsonConfiguration): Promise<ConfigurationResult>;
 export declare function retrieveProjectConfigurationPaths(root: string, plugins: Array<LoadedNxPlugin>): Promise<string[]>;
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function configurationGlobs(plugins: Array<LoadedNxPlugin>): string[];
+export declare function getGlobPatternsOfPlugins(plugins: Array<LoadedNxPlugin>): string[];

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -5,7 +5,7 @@ exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
 exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
 exports.retrieveProjectConfigurationPaths = retrieveProjectConfigurationPaths;
 exports.retrieveProjectConfigurationsWithoutPluginInference = retrieveProjectConfigurationsWithoutPluginInference;
-exports.configurationGlobs = configurationGlobs;
+exports.getGlobPatternsOfPlugins = getGlobPatternsOfPlugins;
 const perf_hooks_1 = require("perf_hooks");
 const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
@@ -41,9 +41,10 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
  */
 async function retrieveProjectConfigurations(plugins, workspaceRoot, nxJson) {
-    const globPatterns = configurationGlobs(plugins);
-    const workspaceFiles = await (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
-    return (0, project_configuration_utils_1.createProjectConfigurations)(workspaceRoot, nxJson, workspaceFiles, plugins);
+    const pluginsWithCreateNodes = plugins.filter((p) => !!p.createNodes);
+    const globPatterns = getGlobPatternsOfPlugins(pluginsWithCreateNodes);
+    const pluginConfigFiles = await (0, workspace_context_1.multiGlobWithWorkspaceContext)(workspaceRoot, globPatterns);
+    return (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(workspaceRoot, nxJson, pluginConfigFiles, pluginsWithCreateNodes);
 }
 async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
     const pluginsToLoad = nxJson?.plugins ?? [];
@@ -56,31 +57,26 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
     const res = await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
     return res;
 }
-function retrieveProjectConfigurationPaths(root, plugins) {
-    const projectGlobPatterns = configurationGlobs(plugins);
-    return (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns);
+async function retrieveProjectConfigurationPaths(root, plugins) {
+    const projectGlobPatterns = getGlobPatternsOfPlugins(plugins);
+    const pluginConfigFiles = await (0, workspace_context_1.multiGlobWithWorkspaceContext)(root, projectGlobPatterns);
+    return pluginConfigFiles.flat();
 }
 const projectsWithoutPluginCache = new Map();
 // TODO: This function is called way too often, it should be optimized without this cache
 async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
     const plugins = await (0, get_plugins_1.getOnlyDefaultPlugins)(); // only load default plugins
-    const projectGlobPatterns = await retrieveProjectConfigurationPaths(root, plugins);
+    const projectGlobPatterns = getGlobPatternsOfPlugins(plugins);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
-    const projectFiles = (await (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns)) ?? [];
-    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, plugins);
+    const projectFiles = (await (0, workspace_context_1.multiGlobWithWorkspaceContext)(root, projectGlobPatterns)) ?? [];
+    const { projects } = await (0, project_configuration_utils_1.createProjectConfigurationsWithPlugins)(root, nxJson, projectFiles, plugins);
     projectsWithoutPluginCache.set(cacheKey, projects);
     return projects;
 }
-function configurationGlobs(plugins) {
-    const globPatterns = [];
-    for (const plugin of plugins) {
-        if ('createNodes' in plugin && plugin.createNodes) {
-            globPatterns.push(plugin.createNodes[0]);
-        }
-    }
-    return globPatterns;
+function getGlobPatternsOfPlugins(plugins) {
+    return plugins.map((p) => p.createNodes[0]);
 }

package/src/utils/workspace-context.d.ts

@@ -10,6 +10,7 @@ export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, pr
  */
 export declare function globWithWorkspaceContextSync(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
 export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[]>;
+export declare function multiGlobWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[][]>;
 export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string>;
 export declare function updateContextWithChangedFiles(workspaceRoot: string, createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
 export declare function updateFilesInContext(workspaceRoot: string, updatedFiles: string[], deletedFiles: string[]): Record<string, string>;

package/src/utils/workspace-context.js

@@ -4,6 +4,7 @@ exports.setupWorkspaceContext = setupWorkspaceContext;
 exports.getNxWorkspaceFilesFromContext = getNxWorkspaceFilesFromContext;
 exports.globWithWorkspaceContextSync = globWithWorkspaceContextSync;
 exports.globWithWorkspaceContext = globWithWorkspaceContext;
+exports.multiGlobWithWorkspaceContext = multiGlobWithWorkspaceContext;
 exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
 exports.updateContextWithChangedFiles = updateContextWithChangedFiles;
 exports.updateFilesInContext = updateFilesInContext;
@@ -50,6 +51,13 @@ async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
         return client_1.daemonClient.glob(globs, exclude);
     }
 }
+async function multiGlobWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.multiGlob(globs, exclude);
+    }
+    return client_1.daemonClient.multiGlob(globs, exclude);
+}
 async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
     if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
         ensureContextAvailable(workspaceRoot);