nx 21.0.0-beta.0 → 21.0.0-beta.2

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

@@ -153,10 +153,37 @@ function isProjectWithNoNameError(e) {
 }
 class ProjectConfigurationsError extends Error {
     constructor(errors, partialProjectConfigurationsResult) {
-        super('Failed to create project configurations');
+        const messageFragments = ['Failed to create project configurations.'];
+        const mergeNodesErrors = [];
+        const unknownErrors = [];
+        for (const e of errors) {
+            if (
+            // Known error type, but unlikely to be caused by the user
+            isMergeNodesError(e)) {
+                mergeNodesErrors.push(e);
+            }
+            else if (
+            // Known errors that are self-explanatory
+            !isAggregateCreateNodesError(e) &&
+                !isProjectsWithNoNameError(e) &&
+                !isMultipleProjectsWithSameNameError(e)) {
+                unknownErrors.push(e);
+            }
+        }
+        if (mergeNodesErrors.length > 0) {
+            messageFragments.push(`This type of error most likely points to an issue within Nx. Please report it.`);
+        }
+        if (unknownErrors.length > 0) {
+            messageFragments.push(`If the error cause is not obvious from the below error messages, running "nx reset" may fix it. Please report the issue if you keep seeing it.`);
+        }
+        super(messageFragments.join(' '));
         this.errors = errors;
         this.partialProjectConfigurationsResult = partialProjectConfigurationsResult;
         this.name = this.constructor.name;
+        this.errors = errors;
+        this.stack = errors
+            .map((error) => indentString(formatErrorStackAndCause(error), 2))
+            .join('\n');
     }
 }
 exports.ProjectConfigurationsError = ProjectConfigurationsError;
@@ -216,7 +243,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/nx-deps-cache.js

@@ -150,10 +150,15 @@ function writeCache(cache, projectGraph, sourceMaps, errors) {
                 computedAt: Date.now(),
             });
             (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
-            (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
-            (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
             (0, fileutils_1.writeJsonFile)(tmpSourceMapPath, sourceMaps);
             (0, node_fs_1.renameSync)(tmpSourceMapPath, exports.nxSourceMaps);
+            // only write the file map if there are no errors
+            // if there were errors, the errors make the filemap invalid
+            // TODO: We should be able to keep the valid part of the filemap if the errors being thrown told us which parts of the filemap were invalid
+            if (errors.length === 0) {
+                (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
+                (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            }
             done = true;
         }
         catch (err) {

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/loaded-nx-plugin.js

@@ -57,22 +57,18 @@ class LoadedNxPlugin {
         if (plugin.preTasksExecution) {
             this.preTasksExecution = async (context) => {
                 const updates = {};
-                let revokeFn;
+                let originalEnv = process.env;
                 if ((0, enabled_1.isIsolationEnabled)() || (0, client_1.isDaemonEnabled)()) {
-                    const { proxy, revoke } = Proxy.revocable(process.env, {
+                    process.env = new Proxy(originalEnv, {
                         set: (target, key, value) => {
                             target[key] = value;
                             updates[key] = value;
                             return true;
                         },
                     });
-                    process.env = proxy;
-                    revokeFn = revoke;
                 }
                 await plugin.preTasksExecution(this.options, context);
-                if (revokeFn) {
-                    revokeFn();
-                }
+                process.env = originalEnv;
                 return updates;
             };
         }

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

@@ -149,7 +149,7 @@ function handleProjectGraphError(opts, e) {
                 bodyLines: bodyLines,
             });
         }
-        else {
+        else if (typeof e.message === 'string') {
             const lines = e.message.split('\n');
             output_1.output.error({
                 title: lines[0],
@@ -159,6 +159,9 @@ function handleProjectGraphError(opts, e) {
                 console.error(e);
             }
         }
+        else {
+            console.error(e);
+        }
         process.exit(1);
     }
     else {
@@ -277,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;
@@ -138,8 +138,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 +234,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 +260,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 +277,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.
@@ -289,7 +303,7 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles,
+                matchingProjectFiles: projectFiles.flat(),
             };
         }
         else {
@@ -298,7 +312,7 @@ plugins) {
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
-                matchingProjectFiles: projectFiles,
+                matchingProjectFiles: projectFiles.flat(),
             });
         }
     });
@@ -309,7 +323,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 +343,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/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

@@ -11,9 +11,8 @@ function getBatchExecutor(executorName, projects) {
     const [nodeModule, exportName] = executorName.split(':');
     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;