nx 21.0.0-beta.1 → 21.0.0-beta.10

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

@@ -4,23 +4,15 @@ exports.TEN_MEGABYTES = exports.DeletedFileChange = exports.WholeFileChange = vo
 exports.isWholeFileChange = isWholeFileChange;
 exports.isDeletedFileChange = isDeletedFileChange;
 exports.calculateFileChanges = calculateFileChanges;
-exports.readWorkspaceConfig = readWorkspaceConfig;
 exports.defaultFileRead = defaultFileRead;
 exports.readPackageJson = readPackageJson;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
-const configuration_1 = require("../config/configuration");
-const workspace_root_1 = require("../utils/workspace-root");
 const fileutils_1 = require("../utils/fileutils");
-const json_diff_1 = require("../utils/json-diff");
-const project_graph_1 = require("./project-graph");
-const angular_json_1 = require("../adapter/angular-json");
 const ignore_1 = require("../utils/ignore");
-const project_configuration_utils_1 = require("./utils/project-configuration-utils");
-const package_json_1 = require("../plugins/package-json");
-const workspace_context_1 = require("../utils/workspace-context");
-const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
+const json_diff_1 = require("../utils/json-diff");
+const workspace_root_1 = require("../utils/workspace-root");
 class WholeFileChange {
     constructor() {
         this.type = 'WholeFileChange';
@@ -100,34 +92,6 @@ function defaultReadFileAtRevision(file, revision) {
         return '';
     }
 }
-/**
- * TODO(v21): Remove this function
- * @deprecated To get projects use {@link retrieveProjectConfigurations} instead. This will be removed in v21.
- */
-function readWorkspaceConfig(opts) {
-    let configuration = null;
-    const root = opts.path || process.cwd();
-    const nxJson = (0, configuration_1.readNxJson)(root);
-    try {
-        const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
-        configuration = {
-            ...nxJson,
-            ...(0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
-        };
-    }
-    catch {
-        configuration = {
-            version: 2,
-            projects: getProjectsSync(root, nxJson),
-        };
-    }
-    if (opts.format === 'angularCli') {
-        return (0, angular_json_1.toOldFormat)(configuration);
-    }
-    else {
-        return configuration;
-    }
-}
 function defaultFileRead(filePath) {
     return (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, filePath), 'utf-8');
 }
@@ -139,42 +103,3 @@ function readPackageJson(root = workspace_root_1.workspaceRoot) {
         return {}; // if package.json doesn't exist
     }
 }
-/**
- * TODO(v21): Remove this function.
- */
-function getProjectsSync(root, nxJson) {
-    /**
-     * We can't update projects that come from plugins anyways, so we are going
-     * to ignore them for now. Plugins should add their own add/create/update methods
-     * if they would like to use devkit to update inferred projects.
-     */
-    const patterns = [
-        '**/project.json',
-        'project.json',
-        ...(0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(root, fileutils_1.readJsonFile),
-    ];
-    const projectFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(root, patterns);
-    const isInPackageJsonWorkspaces = (0, package_json_1.buildPackageJsonWorkspacesMatcher)(root, (f) => (0, fileutils_1.readJsonFile)((0, path_1.join)(root, f)));
-    const rootMap = {};
-    for (const projectFile of projectFiles) {
-        if ((0, path_1.basename)(projectFile) === 'project.json') {
-            const json = (0, fileutils_1.readJsonFile)(projectFile);
-            const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
-            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
-        }
-        else if ((0, path_1.basename)(projectFile) === 'package.json') {
-            const packageJson = (0, fileutils_1.readJsonFile)(projectFile);
-            const config = (0, package_json_1.buildProjectConfigurationFromPackageJson)(packageJson, root, projectFile, nxJson, isInPackageJsonWorkspaces(projectFile));
-            if (!rootMap[config.root]) {
-                (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
-                // Inferred targets, tags, etc don't show up when running generators
-                // This is to help avoid running into issues when trying to update the workspace
-                {
-                    name: config.name,
-                    root: config.root,
-                }, undefined, undefined, true);
-            }
-        }
-    }
-    return (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)(rootMap);
-}

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/in-process-loader.js

@@ -25,7 +25,7 @@ function readPluginPackageJson(pluginName, projects, paths = (0, installation_di
             const localPluginPath = (0, resolve_plugin_1.resolveLocalNxPlugin)(pluginName, projects);
             if (localPluginPath) {
                 const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                if ((0, transpiler_1.pluginTranspilerIsRegistered)()) {
+                if (!(0, transpiler_1.pluginTranspilerIsRegistered)()) {
                     (0, transpiler_1.registerPluginTSTranspiler)();
                 }
                 return {

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_perf_hooks_1 = require("node:perf_hooks");
+node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- start`);
 const messaging_1 = require("./messaging");
 const serializable_error_1 = require("../../../utils/serializable-error");
 const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
@@ -8,6 +10,8 @@ const fs_1 = require("fs");
 if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
+node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- end`);
+node_perf_hooks_1.performance.measure(`plugin worker ${process.pid} code loading`, `plugin worker ${process.pid} code loading -- start`, `plugin worker ${process.pid} code loading -- end`);
 global.NX_GRAPH_CREATION = true;
 global.NX_PLUGIN_WORKER = true;
 let connected = false;
@@ -182,12 +186,14 @@ const server = (0, net_1.createServer)((socket) => {
     });
 });
 server.listen(socketPath);
-setTimeout(() => {
-    if (!connected) {
-        console.error('The plugin worker is exiting as it was not connected to within 5 seconds.');
-        process.exit(1);
-    }
-}, 5000).unref();
+if (process.env.NX_PLUGIN_NO_TIMEOUTS !== 'true') {
+    setTimeout(() => {
+        if (!connected) {
+            console.error('The plugin worker is exiting as it was not connected to within 5 seconds.');
+            process.exit(1);
+        }
+    }, 5000).unref();
+}
 const exitHandler = (exitCode) => () => {
     server.close();
     try {

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

@@ -1,8 +1,9 @@
 import type { ProjectGraph } from '../../config/project-graph';
-import type { PluginConfiguration } from '../../config/nx-json';
+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/plugins/public-api.d.ts

@@ -68,7 +68,7 @@ export interface CreateDependenciesContext {
      */
     readonly externalNodes: ProjectGraph['externalNodes'];
     /**
-     * The configuration of each project in the workspace.
+     * The configuration of each project in the workspace keyed by project name.
      */
     readonly projects: Record<string, ProjectConfiguration>;
     /**

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

@@ -1,2 +1,2 @@
-import { CreateNodesContextV2, CreateNodesFunction, CreateNodesResult } from './public-api';
-export declare function createNodesFromFiles<T = unknown>(createNodes: CreateNodesFunction<T>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;
+import { CreateNodesContext, CreateNodesContextV2, CreateNodesResult } from './public-api';
+export declare function createNodesFromFiles<T = unknown>(createNodes: (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext, idx: number) => CreateNodesResult | Promise<CreateNodesResult>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;

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

@@ -5,12 +5,12 @@ const error_types_1 = require("../error-types");
 async function createNodesFromFiles(createNodes, configFiles, options, context) {
     const results = [];
     const errors = [];
-    await Promise.all(configFiles.map(async (file) => {
+    await Promise.all(configFiles.map(async (file, idx) => {
         try {
             const value = await createNodes(file, options, {
                 ...context,
                 configFiles,
-            });
+            }, idx);
             if (value) {
                 results.push([file, value]);
             }

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>;
@@ -66,9 +66,9 @@ export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConf
 export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
 export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
 /**
- * Expand's `command` syntactic sugar and replaces tokens in options.
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
  * @param target The target to normalize
  * @param project The project that the target belongs to
  * @returns The normalized target configuration
  */
-export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration): TargetConfiguration<any>;
+export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration, workspaceRoot: string, projectsMap: Record<string, ProjectConfiguration>): TargetConfiguration<any>;

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;
@@ -21,6 +21,7 @@ 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");
+const executor_utils_1 = require("../../command-line/run/executor-utils");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -138,8 +139,20 @@ skipTargetNormalization) {
             const normalizedTarget = skipTargetNormalization
                 ? target
                 : resolveCommandSyntacticSugar(target, project.root);
-            const mergedTarget = mergeTargetConfigurations(normalizedTarget, matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
-            updatedProjectConfiguration.targets[targetName] = mergedTarget;
+            let matchingTargets = [];
+            if ((0, globs_1.isGlobPattern)(targetName)) {
+                // find all targets matching the glob pattern
+                // this will map atomized targets to the glob pattern same as it does for targetDefaults
+                matchingTargets = Object.keys(updatedProjectConfiguration.targets).filter((key) => (0, minimatch_1.minimatch)(key, targetName));
+            }
+            // If no matching targets were found, we can assume that the target name is not (meant to be) a glob pattern
+            if (!matchingTargets.length) {
+                matchingTargets = [targetName];
+            }
+            for (const matchingTargetName of matchingTargets) {
+                const mergedTarget = mergeTargetConfigurations(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`);
+                updatedProjectConfiguration.targets[matchingTargetName] = mergedTarget;
+            }
         }
     }
     projectRootMap[updatedProjectConfiguration.root] =
@@ -222,7 +235,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 +261,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 +278,10 @@ plugins) {
                     e
                 : // This represents a single plugin erroring out with a hard error.
                     new error_types_1.AggregateCreateNodesError([[null, e]], []);
+            if (pluginIndex !== undefined) {
+                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.
@@ -280,7 +295,7 @@ plugins) {
     }
     return Promise.all(results).then((results) => {
         spinner?.cleanup();
-        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, errors);
+        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, root, 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');
         if (errors.length === 0) {
@@ -289,7 +304,7 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles,
+                matchingProjectFiles: projectFiles.flat(),
             };
         }
         else {
@@ -298,18 +313,18 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles,
+                matchingProjectFiles: projectFiles.flat(),
             });
         }
     });
 }
-function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
+function mergeCreateNodesResults(results, nxJsonConfiguration, workspaceRoot, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
     const projectRootMap = {};
     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,14 +344,14 @@ function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
                     file,
                     pluginName,
                     error,
-                    pluginIndex: index,
+                    pluginIndex,
                 }));
             }
         }
         Object.assign(externalNodes, pluginExternalNodes);
     }
     try {
-        validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration, configurationSourceMaps);
+        validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJsonConfiguration, configurationSourceMaps);
     }
     catch (e) {
         if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
@@ -414,7 +429,7 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     }
     return projects;
 }
-function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
+function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
     // Name -> Project, used to validate that all projects have unique names
     const projects = {};
     // If there are projects that have the same name, that is an error.
@@ -447,7 +462,7 @@ function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration,
                 throw e;
             }
         }
-        normalizeTargets(project, sourceMaps, nxJsonConfiguration);
+        normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects);
     }
     if (conflicts.size > 0) {
         throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
@@ -457,15 +472,19 @@ function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration,
     }
     return projectRootMap;
 }
-function normalizeTargets(project, sourceMaps, nxJsonConfiguration) {
+function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
+/**
+ * Project configurations keyed by project name
+ */
+projects) {
     for (const targetName in project.targets) {
-        project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
+        project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects);
         const projectSourceMaps = sourceMaps[project.root];
         const targetConfig = project.targets[targetName];
         const targetDefaults = deepClone(readTargetDefaultsForTarget(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor));
         // We only apply defaults if they exist
         if (targetDefaults && isCompatibleTarget(targetConfig, targetDefaults)) {
-            project.targets[targetName] = mergeTargetDefaultWithTargetDefinition(targetName, project, normalizeTarget(targetDefaults, project), projectSourceMaps);
+            project.targets[targetName] = mergeTargetDefaultWithTargetDefinition(targetName, project, normalizeTarget(targetDefaults, project, workspaceRoot, projects), projectSourceMaps);
         }
         if (
         // If the target has no executor or command, it doesn't do anything
@@ -775,12 +794,12 @@ function resolveCommandSyntacticSugar(target, key) {
     }
 }
 /**
- * Expand's `command` syntactic sugar and replaces tokens in options.
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
  * @param target The target to normalize
  * @param project The project that the target belongs to
  * @returns The normalized target configuration
  */
-function normalizeTarget(target, project) {
+function normalizeTarget(target, project, workspaceRoot, projectsMap) {
     target = {
         ...target,
         configurations: {
@@ -793,5 +812,19 @@ function normalizeTarget(target, project) {
         target.configurations[configuration] = resolveNxTokensInOptions(target.configurations[configuration], project, `${project.root}:${target}:${configuration}`);
     }
     target.parallelism ??= true;
+    if (target.executor && !('continuous' in target)) {
+        try {
+            const [executorNodeModule, executorName] = (0, executor_utils_1.parseExecutor)(target.executor);
+            const { schema } = (0, executor_utils_1.getExecutorInformation)(executorNodeModule, executorName, workspaceRoot, projectsMap);
+            if (schema.continuous) {
+                target.continuous ??= schema.continuous;
+            }
+        }
+        catch (e) {
+            // If the executor is not found, we assume that it is not a valid executor.
+            // This means that we should not set the continuous property.
+            // We could throw an error here, but it would be better to just ignore it.
+        }
+    }
     return target;
 }

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/tasks-runner/batch/batch-messages.d.ts

@@ -1,5 +1,6 @@
 import type { TaskResult } from '../../config/misc-interfaces';
 import type { TaskGraph } from '../../config/task-graph';
+import type { ProjectGraph } from '../../config/project-graph';
 export declare enum BatchMessageType {
     RunTasks = 0,
     CompleteTask = 1,
@@ -18,6 +19,7 @@ export interface BatchTaskResult {
 export interface RunTasksMessage {
     type: BatchMessageType.RunTasks;
     executorName: string;
+    projectGraph: ProjectGraph;
     batchTaskGraph: TaskGraph;
     fullTaskGraph: TaskGraph;
 }

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

@@ -8,12 +8,11 @@ const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("../../command-line/run/executor-utils");
 function getBatchExecutor(executorName, projects) {
-    const [nodeModule, exportName] = executorName.split(':');
+    const [nodeModule, exportName] = (0, executor_utils_1.parseExecutor)(executorName);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);
 }
-async function runTasks(executorName, batchTaskGraph, fullTaskGraph) {
+async function runTasks(executorName, projectGraph, batchTaskGraph, fullTaskGraph) {
     const input = {};
-    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const nxJsonConfiguration = (0, configuration_1.readNxJson)();
     const batchExecutor = getBatchExecutor(executorName, projectsConfigurations.projects);
@@ -66,7 +65,7 @@ async function runTasks(executorName, batchTaskGraph, fullTaskGraph) {
 process.on('message', async (message) => {
     switch (message.type) {
         case batch_messages_1.BatchMessageType.RunTasks: {
-            const results = await runTasks(message.executorName, message.batchTaskGraph, message.fullTaskGraph);
+            const results = await runTasks(message.executorName, message.projectGraph, message.batchTaskGraph, message.fullTaskGraph);
             process.send({
                 type: batch_messages_1.BatchMessageType.CompleteBatchExecution,
                 results,

package/src/tasks-runner/cache.d.ts

@@ -15,6 +15,7 @@ export declare function dbCacheEnabled(nxJson?: NxJsonConfiguration): boolean;
 export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
 export declare class DbCache {
     private readonly options;
+    private nxJson;
     private cache;
     private remoteCache;
     private remoteCachePromise;
@@ -25,18 +26,20 @@ export declare class DbCache {
     });
     init(): Promise<void>;
     get(task: Task): Promise<CachedResult | null>;
+    getUsedCacheSpace(): number;
     private applyRemoteCacheResults;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
-    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
+    copyFilesFromCache(_: string, cachedResult: CachedResult, outputs: string[]): Promise<number>;
     removeOldCacheRecords(): void;
     temporaryOutputPath(task: Task): string;
     private getRemoteCache;
     private _getRemoteCache;
-    private getPowerpackS3Cache;
-    private getPowerpackSharedCache;
-    private getPowerpackGcsCache;
-    private getPowerpackAzureCache;
-    private getPowerpackCache;
+    private getS3Cache;
+    private getSharedCache;
+    private getGcsCache;
+    private getAzureCache;
+    private getHttpCache;
+    private resolveRemoteCache;
     private resolvePackage;
     private assertCacheIsValid;
 }
@@ -66,3 +69,14 @@ export declare class Cache {
     private createCacheDir;
     private createTerminalOutputsDir;
 }
+/**
+ * Converts a string representation of a max cache size to a number.
+ *
+ * e.g. '1GB' -> 1024 * 1024 * 1024
+ *      '1MB' -> 1024 * 1024
+ *      '1KB' -> 1024
+ *
+ * @param maxCacheSize Max cache size as specified in nx.json
+ */
+export declare function parseMaxCacheSize(maxCacheSize: string | number): number | undefined;
+export declare function formatCacheSize(maxCacheSize: number, decimals?: number): string;