nx 21.0.0-beta.1 → 21.0.0-beta.3

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/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/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>;

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;

package/src/tasks-runner/cache.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
 exports.dbCacheEnabled = dbCacheEnabled;
 exports.getCache = getCache;
+exports.parseMaxCacheSize = parseMaxCacheSize;
+exports.formatCacheSize = formatCacheSize;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
@@ -68,7 +70,10 @@ function getCache(options) {
 class DbCache {
     constructor(options) {
         this.options = options;
-        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)());
+        this.nxJson = (0, nx_json_1.readNxJson)();
+        this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)(), undefined, this.nxJson.maxCacheSize !== undefined
+            ? parseMaxCacheSize(this.nxJson.maxCacheSize)
+            : (0, native_1.getDefaultMaxCacheSize)(cache_directory_1.cacheDir));
         this.isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
     }
     async init() {
@@ -83,6 +88,7 @@ class DbCache {
         if (res) {
             return {
                 ...res,
+                terminalOutput: res.terminalOutput ?? '',
                 remote: false,
             };
         }
@@ -91,9 +97,10 @@ class DbCache {
             // attempt remote cache
             const res = await this.remoteCache.retrieve(task.hash, this.cache.cacheDirectory);
             if (res) {
-                this.applyRemoteCacheResults(task.hash, res);
+                this.applyRemoteCacheResults(task.hash, res, task.outputs);
                 return {
                     ...res,
+                    terminalOutput: res.terminalOutput ?? '',
                     remote: true,
                 };
             }
@@ -105,8 +112,11 @@ class DbCache {
             return null;
         }
     }
-    applyRemoteCacheResults(hash, res) {
-        return this.cache.applyRemoteCacheResults(hash, res);
+    getUsedCacheSpace() {
+        return this.cache.getCacheSize();
+    }
+    applyRemoteCacheResults(hash, res, outputs) {
+        return this.cache.applyRemoteCacheResults(hash, res, outputs);
     }
     async put(task, terminalOutput, outputs, code) {
         return tryAndRetry(async () => {
@@ -155,26 +165,49 @@ class DbCache {
             }
         }
         else {
-            return ((await this.getPowerpackS3Cache()) ??
-                (await this.getPowerpackSharedCache()) ??
-                (await this.getPowerpackGcsCache()) ??
-                (await this.getPowerpackAzureCache()) ??
+            return ((await this.getS3Cache()) ??
+                (await this.getSharedCache()) ??
+                (await this.getGcsCache()) ??
+                (await this.getAzureCache()) ??
+                this.getHttpCache() ??
                 null);
         }
     }
-    getPowerpackS3Cache() {
-        return this.getPowerpackCache('@nx/powerpack-s3-cache');
-    }
-    getPowerpackSharedCache() {
-        return this.getPowerpackCache('@nx/powerpack-shared-fs-cache');
-    }
-    getPowerpackGcsCache() {
-        return this.getPowerpackCache('@nx/powerpack-gcs-cache');
-    }
-    getPowerpackAzureCache() {
-        return this.getPowerpackCache('@nx/powerpack-azure-cache');
+    async getS3Cache() {
+        const cache = await this.resolveRemoteCache('@nx/s3-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-s3-cache');
+    }
+    async getSharedCache() {
+        const cache = await this.resolveRemoteCache('@nx/shared-fs-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-shared-fs-cache');
+    }
+    async getGcsCache() {
+        const cache = await this.resolveRemoteCache('@nx/gcs-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-gcs-cache');
+    }
+    async getAzureCache() {
+        const cache = await this.resolveRemoteCache('@nx/azure-cache');
+        if (cache)
+            return cache;
+        return this.resolveRemoteCache('@nx/powerpack-azure-cache');
+    }
+    getHttpCache() {
+        if (process.env.NX_SELF_HOSTED_REMOTE_CACHE_SERVER) {
+            if (native_1.IS_WASM) {
+                logger_1.logger.warn('The HTTP remote cache is not yet supported in the wasm build of Nx.');
+                return null;
+            }
+            return new native_1.HttpRemoteCache();
+        }
+        return null;
     }
-    async getPowerpackCache(pkg) {
+    async resolveRemoteCache(pkg) {
         let getRemoteCache = null;
         try {
             getRemoteCache = (await Promise.resolve(`${this.resolvePackage(pkg)}`).then(s => require(s))).getRemoteCache;
@@ -455,3 +488,54 @@ function tryAndRetry(fn) {
     };
     return _try();
 }
+/**
+ * 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
+ */
+function parseMaxCacheSize(maxCacheSize) {
+    if (maxCacheSize === null || maxCacheSize === undefined) {
+        return undefined;
+    }
+    let regexResult = maxCacheSize
+        // Covers folks who accidentally specify as a number rather than a string
+        .toString()
+        // Match a number followed by an optional unit (KB, MB, GB), with optional whitespace between the number and unit
+        .match(/^(?<size>[\d|.]+)\s?((?<unit>[KMG]?B)?)$/);
+    if (!regexResult) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize}. Must be a number followed by an optional unit (KB, MB, GB)`);
+    }
+    let sizeString = regexResult.groups.size;
+    let unit = regexResult.groups.unit;
+    if ([...sizeString].filter((c) => c === '.').length > 1) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize} (multiple decimal points in size)`);
+    }
+    let size = parseFloat(sizeString);
+    if (isNaN(size)) {
+        throw new Error(`Invalid max cache size specified in nx.json: ${maxCacheSize} (${sizeString} is not a number)`);
+    }
+    switch (unit) {
+        case 'KB':
+            return size * 1024;
+        case 'MB':
+            return size * 1024 * 1024;
+        case 'GB':
+            return size * 1024 * 1024 * 1024;
+        default:
+            return size;
+    }
+}
+function formatCacheSize(maxCacheSize, decimals = 2) {
+    const exponents = ['B', 'KB', 'MB', 'GB'];
+    let exponent = 0;
+    let size = maxCacheSize;
+    while (size >= 1024 && exponent < exponents.length - 1) {
+        size /= 1024;
+        exponent++;
+    }
+    return `${size.toFixed(decimals)} ${exponents[exponent]}`;
+}

package/src/tasks-runner/create-task-graph.d.ts

@@ -24,7 +24,6 @@ export declare class ProcessTasks {
     private createDummyTask;
     createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
     resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
-    getId(project: string, target: string, configuration: string | undefined): string;
 }
 export declare function createTaskGraph(projectGraph: ProjectGraph, extraTargetDependencies: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
 export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;
@@ -41,3 +40,4 @@ export declare function filterDummyTasks(dependencies: {
 export declare function getNonDummyDeps(currentTask: string, dependencies: {
     [k: string]: string[];
 }, cycles?: Set<string>, seen?: Set<string>): string[];
+export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;