nx 19.8.0 → 19.8.2

package/src/daemon/server/sync-generators.js

@@ -72,11 +72,16 @@ function collectAndScheduleSyncGenerators(projectGraph) {
     // a change imply we need to re-run all the generators
     // make sure to schedule all the collected generators
     scheduledGenerators.clear();
-    if (!registeredSyncGenerators.size) {
+    if (!registeredSyncGenerators.globalGenerators.size &&
+        !registeredSyncGenerators.taskGenerators.size) {
         // there are no generators to run
         return;
     }
-    for (const generator of registeredSyncGenerators) {
+    const uniqueSyncGenerators = new Set([
+        ...registeredSyncGenerators.globalGenerators,
+        ...registeredSyncGenerators.taskGenerators,
+    ]);
+    for (const generator of uniqueSyncGenerators) {
         scheduledGenerators.add(generator);
     }
     log('scheduling:', [...scheduledGenerators]);
@@ -102,7 +107,7 @@ function collectAndScheduleSyncGenerators(projectGraph) {
 }
 async function getCachedRegisteredSyncGenerators() {
     log('get registered sync generators');
-    if (!registeredSyncGenerators) {
+    if (!registeredGlobalSyncGenerators && !registeredTaskSyncGenerators) {
         log('no registered sync generators, collecting them');
         const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
         collectAllRegisteredSyncGenerators(projectGraph);
@@ -110,7 +115,10 @@ async function getCachedRegisteredSyncGenerators() {
     else {
         log('registered sync generators already collected, returning them');
     }
-    return [...registeredSyncGenerators];
+    return {
+        globalGenerators: [...registeredGlobalSyncGenerators],
+        taskGenerators: [...registeredTaskSyncGenerators],
+    };
 }
 async function getFromCacheOrRunGenerators(generators) {
     let projects;
@@ -296,23 +304,33 @@ function collectAllRegisteredSyncGenerators(projectGraph) {
     else {
         log('nx.json hash is the same, not collecting global sync generators');
     }
-    const generators = new Set([
-        ...registeredTaskSyncGenerators,
-        ...registeredGlobalSyncGenerators,
-    ]);
     if (!registeredSyncGenerators) {
-        registeredSyncGenerators = generators;
+        registeredSyncGenerators = {
+            globalGenerators: registeredGlobalSyncGenerators,
+            taskGenerators: registeredTaskSyncGenerators,
+        };
         return;
     }
-    for (const generator of registeredSyncGenerators) {
-        if (!generators.has(generator)) {
-            registeredSyncGenerators.delete(generator);
+    for (const generator of registeredSyncGenerators.globalGenerators) {
+        if (!registeredGlobalSyncGenerators.has(generator)) {
+            registeredSyncGenerators.globalGenerators.delete(generator);
             syncGeneratorsCacheResultPromises.delete(generator);
         }
     }
-    for (const generator of generators) {
-        if (!registeredSyncGenerators.has(generator)) {
-            registeredSyncGenerators.add(generator);
+    for (const generator of registeredSyncGenerators.taskGenerators) {
+        if (!registeredTaskSyncGenerators.has(generator)) {
+            registeredSyncGenerators.taskGenerators.delete(generator);
+            syncGeneratorsCacheResultPromises.delete(generator);
+        }
+    }
+    for (const generator of registeredGlobalSyncGenerators) {
+        if (!registeredSyncGenerators.globalGenerators.has(generator)) {
+            registeredSyncGenerators.globalGenerators.add(generator);
+        }
+    }
+    for (const generator of registeredTaskSyncGenerators) {
+        if (!registeredSyncGenerators.taskGenerators.has(generator)) {
+            registeredSyncGenerators.taskGenerators.add(generator);
         }
     }
 }

package/src/daemon/tmp-dir.js

@@ -11,8 +11,7 @@ exports.removeSocketDir = removeSocketDir;
  * location within the OS's tmp directory where we write log files for background processes
  * and where we create the actual unix socket/named pipe for the daemon.
  */
-const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const path_1 = require("path");
 const cache_directory_1 = require("../utils/cache-directory");
 const crypto_1 = require("crypto");
@@ -26,15 +25,15 @@ const getDaemonSocketDir = () => (0, path_1.join)(getSocketDir(),
 exports.getDaemonSocketDir = getDaemonSocketDir;
 function writeDaemonLogs(error) {
     const file = (0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'daemon-error.log');
-    (0, fs_1.writeFileSync)(file, error);
+    (0, node_fs_1.writeFileSync)(file, error);
     return file;
 }
 function markDaemonAsDisabled() {
-    (0, fs_1.writeFileSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'), 'true');
+    (0, node_fs_1.writeFileSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'), 'true');
 }
 function isDaemonDisabled() {
     try {
-        (0, fs_1.statSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'));
+        (0, node_fs_1.statSync)((0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'disabled'));
         return true;
     }
     catch (e) {
@@ -56,7 +55,7 @@ function getSocketDir(alreadyUnique = false) {
         const dir = process.env.NX_SOCKET_DIR ??
             process.env.NX_DAEMON_SOCKET_DIR ??
             (alreadyUnique ? tmp_1.tmpdir : socketDirName());
-        (0, fs_extra_1.ensureDirSync)(dir);
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
         return dir;
     }
     catch (e) {
@@ -65,7 +64,7 @@ function getSocketDir(alreadyUnique = false) {
 }
 function removeSocketDir() {
     try {
-        (0, fs_extra_1.rmSync)(getSocketDir(), { recursive: true, force: true });
+        (0, node_fs_1.rmSync)(getSocketDir(), { recursive: true, force: true });
     }
     catch (e) { }
 }

package/src/executors/run-commands/run-commands.impl.js

@@ -231,6 +231,7 @@ function nodeProcess(commandConfig, cwd, env, readyWhenStatus, streamOutput = tr
             maxBuffer: exports.LARGE_BUFFER,
             env,
             cwd,
+            windowsHide: true,
         });
         childProcesses.add(childProcess);
         childProcess.stdout.on('data', (data) => {

package/src/executors/run-script/run-script.impl.js

@@ -35,6 +35,7 @@ function nodeProcess(command, cwd, env) {
         stdio: ['inherit', 'inherit', 'inherit'],
         cwd,
         env,
+        windowsHide: true,
     });
 }
 async function ptyProcess(command, cwd, env) {

package/src/generators/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Mode } from 'fs';
+import type { Mode } from 'node:fs';
 /**
  * Options to set when writing a file in the Virtual file system tree.
  */

package/src/generators/tree.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FsTree = void 0;
 exports.flushChanges = flushChanges;
 exports.printChanges = printChanges;
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const logger_1 = require("../utils/logger");
 const output_1 = require("../utils/output");
 const path_1 = require("path");
@@ -228,22 +228,22 @@ class FsTree {
     }
     fsReadDir(dirPath) {
         try {
-            return (0, fs_extra_1.readdirSync)((0, path_1.join)(this.root, dirPath));
+            return (0, node_fs_1.readdirSync)((0, path_1.join)(this.root, dirPath));
         }
         catch {
             return [];
         }
     }
     fsIsFile(filePath) {
-        const stat = (0, fs_extra_1.statSync)((0, path_1.join)(this.root, filePath));
+        const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
         return stat.isFile();
     }
     fsReadFile(filePath) {
-        return (0, fs_extra_1.readFileSync)((0, path_1.join)(this.root, filePath));
+        return (0, node_fs_1.readFileSync)((0, path_1.join)(this.root, filePath));
     }
     fsExists(filePath) {
         try {
-            const stat = (0, fs_extra_1.statSync)((0, path_1.join)(this.root, filePath));
+            const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
             return stat.isFile() || stat.isDirectory();
         }
         catch {
@@ -279,18 +279,18 @@ function flushChanges(root, fileChanges) {
     fileChanges.forEach((f) => {
         const fpath = (0, path_1.join)(root, f.path);
         if (f.type === 'CREATE') {
-            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(fpath));
-            (0, fs_extra_1.writeFileSync)(fpath, f.content);
+            (0, node_fs_1.mkdirSync)((0, path_1.dirname)(fpath), { recursive: true });
+            (0, node_fs_1.writeFileSync)(fpath, f.content);
             if (f.options?.mode)
-                (0, fs_extra_1.chmodSync)(fpath, f.options.mode);
+                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
         }
         else if (f.type === 'UPDATE') {
-            (0, fs_extra_1.writeFileSync)(fpath, f.content);
+            (0, node_fs_1.writeFileSync)(fpath, f.content);
             if (f.options?.mode)
-                (0, fs_extra_1.chmodSync)(fpath, f.options.mode);
+                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
         }
         else if (f.type === 'DELETE') {
-            (0, fs_extra_1.removeSync)(fpath);
+            (0, node_fs_1.rmSync)(fpath, { recursive: true, force: true });
         }
     });
 }

package/src/native/index.d.ts

@@ -28,7 +28,7 @@ export declare class ImportResult {
 
 export declare class NxCache {
   cacheDirectory: string
-  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<Connection>)
+  constructor(workspaceRoot: string, cachePath: string, dbConnection: ExternalObject<Connection>, linkTaskDetails?: boolean | undefined | null)
   get(hash: string): CachedResult | null
   put(hash: string, terminalOutput: string, outputs: Array<string>, code: number): void
   applyRemoteCacheResults(hash: string, result: CachedResult): void

package/src/nx-cloud/generators/connect-to-nx-cloud/connect-to-nx-cloud.js

@@ -32,7 +32,7 @@ function getRootPackageName(tree) {
 }
 function getNxInitDate() {
     try {
-        const nxInitIso = (0, child_process_1.execSync)('git log --diff-filter=A --follow --format=%aI -- nx.json | tail -1', { stdio: 'pipe' })
+        const nxInitIso = (0, child_process_1.execSync)('git log --diff-filter=A --follow --format=%aI -- nx.json | tail -1', { stdio: 'pipe', windowsHide: true })
             .toString()
             .trim();
         const nxInitDate = new Date(nxInitIso);

package/src/plugins/js/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDependencies = exports.createNodes = exports.name = void 0;
 const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("../../utils/cache-directory");
@@ -96,7 +95,7 @@ function lockFileNeedsReprocessing(lockHash) {
     }
 }
 function writeLastProcessedLockfileHash(hash, lockFile) {
-    (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(lockFileHashFile));
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(lockFileHashFile), { recursive: true });
     (0, fs_1.writeFileSync)(cachedParsedLockFile, JSON.stringify(lockFile, null, 2));
     (0, fs_1.writeFileSync)(lockFileHashFile, hash);
 }

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

@@ -91,6 +91,7 @@ function defaultReadFileAtRevision(file, revision) {
             : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
                 maxBuffer: exports.TEN_MEGABYTES,
                 stdio: ['pipe', 'pipe', 'ignore'],
+                windowsHide: true,
             })
                 .toString()
                 .trim();

package/src/project-graph/nx-deps-cache.js

@@ -8,8 +8,7 @@ exports.createProjectFileMapCache = createProjectFileMapCache;
 exports.writeCache = writeCache;
 exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
 exports.extractCachedFileData = extractCachedFileData;
-const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
+const node_fs_1 = require("node:fs");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("../utils/cache-directory");
@@ -19,8 +18,8 @@ exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.workspaceDataDirecto
 exports.nxFileMap = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'file-map.json');
 function ensureCacheDirectory() {
     try {
-        if (!(0, fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
-            (0, fs_extra_1.ensureDirSync)(cache_directory_1.workspaceDataDirectory);
+        if (!(0, node_fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
+            (0, node_fs_1.mkdirSync)(cache_directory_1.workspaceDataDirectory, { recursive: true });
         }
     }
     catch (e) {
@@ -102,9 +101,9 @@ function writeCache(cache, projectGraph) {
         const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
         try {
             (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, projectGraph);
-            (0, fs_extra_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
+            (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
             (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
-            (0, fs_extra_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
             done = true;
         }
         catch (err) {

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

@@ -1,5 +1,6 @@
 import { DefaultTasksRunnerOptions, RemoteCache } from './default-tasks-runner';
 import { Task } from '../config/task-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
 export type CachedResult = {
     terminalOutput: string;
     outputsPath: string;
@@ -10,7 +11,7 @@ export type TaskWithCachedResult = {
     task: Task;
     cachedResult: CachedResult;
 };
-export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
+export declare function getCache(nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions): DbCache | Cache;
 export declare class DbCache {
     private readonly options;
     private cache;
@@ -30,6 +31,7 @@ export declare class DbCache {
     private _getRemoteCache;
     private getPowerpackS3Cache;
     private getPowerpackSharedCache;
+    private getPowerpackCache;
     private resolvePackage;
     private assertCacheIsValid;
 }

package/src/tasks-runner/cache.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
 exports.getCache = getCache;
 const workspace_root_1 = require("../utils/workspace-root");
-const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const default_tasks_runner_1 = require("./default-tasks-runner");
 const child_process_1 = require("child_process");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
 const cache_directory_1 = require("../utils/cache-directory");
 const node_machine_id_1 = require("node-machine-id");
 const native_1 = require("../native");
@@ -18,9 +19,9 @@ const update_manager_1 = require("../nx-cloud/update-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const is_ci_1 = require("../utils/is-ci");
 const output_1 = require("../utils/output");
-function getCache(options) {
+function getCache(nxJson, options) {
     return process.env.NX_DISABLE_DB !== 'true' &&
-        process.env.NX_DB_CACHE === 'true'
+        (nxJson.enableDbCache === true || process.env.NX_DB_CACHE === 'true')
         ? new DbCache({
             // Remove this in Nx 21
             nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
@@ -114,23 +115,21 @@ class DbCache {
                 null);
         }
     }
-    async getPowerpackS3Cache() {
-        try {
-            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-s3-cache')}`).then(s => require(s));
-            return getRemoteCache();
-        }
-        catch {
-            return null;
-        }
+    getPowerpackS3Cache() {
+        return this.getPowerpackCache('@nx/powerpack-s3-cache');
+    }
+    getPowerpackSharedCache() {
+        return this.getPowerpackCache('@nx/powerpack-shared-fs-cache');
     }
-    async getPowerpackSharedCache() {
+    async getPowerpackCache(pkg) {
+        let getRemoteCache = null;
         try {
-            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-shared-fs-cache')}`).then(s => require(s));
-            return getRemoteCache();
+            getRemoteCache = (await Promise.resolve(`${this.resolvePackage(pkg)}`).then(s => require(s))).getRemoteCache;
         }
         catch {
             return null;
         }
+        return getRemoteCache();
     }
     resolvePackage(pkg) {
         return require.resolve(pkg, {
@@ -183,6 +182,7 @@ class Cache {
                     stdio: 'ignore',
                     detached: true,
                     shell: false,
+                    windowsHide: true,
                 });
                 p.unref();
             }
@@ -234,13 +234,13 @@ class Cache {
             // might be left overs from partially-completed cache invocations
             await this.remove(tdCommit);
             await this.remove(td);
-            await (0, fs_extra_1.mkdir)(td);
-            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'terminalOutput'), terminalOutput ?? 'no terminal output');
-            await (0, fs_extra_1.mkdir)((0, path_1.join)(td, 'outputs'));
+            await (0, promises_1.mkdir)(td, { recursive: true });
+            await (0, promises_1.writeFile)((0, path_1.join)(td, 'terminalOutput'), terminalOutput ?? 'no terminal output');
+            await (0, promises_1.mkdir)((0, path_1.join)(td, 'outputs'));
             const expandedOutputs = await this.expandOutputsInWorkspace(outputs);
             await Promise.all(expandedOutputs.map(async (f) => {
                 const src = (0, path_1.join)(this.root, f);
-                if (await (0, fs_extra_1.pathExists)(src)) {
+                if ((0, node_fs_1.existsSync)(src)) {
                     const cached = (0, path_1.join)(td, 'outputs', f);
                     await this.copy(src, cached);
                 }
@@ -249,15 +249,15 @@ class Cache {
             // creating this file is atomic, whereas creating a folder is not.
             // so if the process gets terminated while we are copying stuff into cache,
             // the cache entry won't be used.
-            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'code'), code.toString());
-            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'source'), await this.currentMachineId());
-            await (0, fs_extra_1.writeFile)(tdCommit, 'true');
+            await (0, promises_1.writeFile)((0, path_1.join)(td, 'code'), code.toString());
+            await (0, promises_1.writeFile)((0, path_1.join)(td, 'source'), await this.currentMachineId());
+            await (0, promises_1.writeFile)(tdCommit, 'true');
             if (this.options.remoteCache) {
                 await this.options.remoteCache.store(task.hash, this.cachePath);
             }
             if (terminalOutput) {
                 const outputPath = this.temporaryOutputPath(task);
-                await (0, fs_extra_1.writeFile)(outputPath, terminalOutput);
+                await (0, promises_1.writeFile)(outputPath, terminalOutput);
             }
         });
     }
@@ -266,7 +266,7 @@ class Cache {
             const expandedOutputs = await this.expandOutputsInCache(outputs, cachedResult);
             await Promise.all(expandedOutputs.map(async (f) => {
                 const cached = (0, path_1.join)(cachedResult.outputsPath, f);
-                if (await (0, fs_extra_1.pathExists)(cached)) {
+                if ((0, node_fs_1.existsSync)(cached)) {
                     const src = (0, path_1.join)(this.root, f);
                     await this.remove(src);
                     await this.copy(cached, src);
@@ -322,11 +322,11 @@ class Cache {
     async getFromLocalDir(task) {
         const tdCommit = (0, path_1.join)(this.cachePath, `${task.hash}.commit`);
         const td = (0, path_1.join)(this.cachePath, task.hash);
-        if (await (0, fs_extra_1.pathExists)(tdCommit)) {
-            const terminalOutput = await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'terminalOutput'), 'utf-8');
+        if ((0, node_fs_1.existsSync)(tdCommit)) {
+            const terminalOutput = await (0, promises_1.readFile)((0, path_1.join)(td, 'terminalOutput'), 'utf-8');
             let code = 0;
             try {
-                code = Number(await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'code'), 'utf-8'));
+                code = Number(await (0, promises_1.readFile)((0, path_1.join)(td, 'code'), 'utf-8'));
             }
             catch { }
             return {
@@ -343,7 +343,7 @@ class Cache {
         const td = (0, path_1.join)(this.cachePath, task.hash);
         let sourceMachineId = null;
         try {
-            sourceMachineId = await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'source'), 'utf-8');
+            sourceMachineId = await (0, promises_1.readFile)((0, path_1.join)(td, 'source'), 'utf-8');
         }
         catch { }
         if (sourceMachineId && sourceMachineId != (await this.currentMachineId())) {
@@ -362,12 +362,12 @@ class Cache {
         }
     }
     createCacheDir() {
-        (0, fs_extra_1.mkdirSync)(cache_directory_1.cacheDir, { recursive: true });
+        (0, node_fs_1.mkdirSync)(cache_directory_1.cacheDir, { recursive: true });
         return cache_directory_1.cacheDir;
     }
     createTerminalOutputsDir() {
         const path = (0, path_1.join)(this.cachePath, 'terminalOutputs');
-        (0, fs_extra_1.mkdirSync)(path, { recursive: true });
+        (0, node_fs_1.mkdirSync)(path, { recursive: true });
         return path;
     }
 }

package/src/tasks-runner/default-tasks-runner.js

@@ -56,7 +56,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 async function runAllTasks(tasks, options, context) {
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

package/src/tasks-runner/life-cycles/formatting-utils.d.ts

@@ -1,3 +1,3 @@
 import { Task } from '../../config/task-graph';
 export declare function formatFlags(leftPadding: string, flag: string, value: any): string;
-export declare function formatTargetsAndProjects(projectNames: string[], targets: string[], tasks: Task[]): any;
+export declare function formatTargetsAndProjects(projectNames: string[], targets: string[], tasks: Task[]): string;

package/src/tasks-runner/life-cycles/formatting-utils.js

@@ -20,24 +20,36 @@ function formatValue(value) {
     }
 }
 function formatTargetsAndProjects(projectNames, targets, tasks) {
-    if (tasks.length === 1)
-        return `target ${targets[0]} for project ${projectNames[0]}`;
-    let text;
-    const project = projectNames.length === 1
-        ? `project ${projectNames[0]}`
-        : `${projectNames.length} projects`;
+    let targetsText = '';
+    let projectsText = '';
+    let dependentTasksText = '';
+    const tasksTargets = new Set();
+    const tasksProjects = new Set();
+    const dependentTasks = new Set();
+    tasks.forEach((task) => {
+        tasksTargets.add(task.target.target);
+        tasksProjects.add(task.target.project);
+        if (!projectNames.includes(task.target.project) ||
+            !targets.includes(task.target.target)) {
+            dependentTasks.add(task);
+        }
+    });
+    targets = targets.filter((t) => tasksTargets.has(t)); // filter out targets that don't exist
+    projectNames = projectNames.filter((p) => tasksProjects.has(p)); // filter out projects that don't exist
     if (targets.length === 1) {
-        text = `target ${output_1.output.bold(targets[0])} for ${project}`;
+        targetsText = `target ${output_1.output.bold(targets[0])}`;
     }
     else {
-        text = `targets ${targets
-            .map((t) => output_1.output.bold(t))
-            .join(', ')} for ${project}`;
+        targetsText = `targets ${targets.map((t) => output_1.output.bold(t)).join(', ')}`;
     }
-    const dependentTasks = tasks.filter((t) => projectNames.indexOf(t.target.project) === -1 ||
-        targets.indexOf(t.target.target) === -1).length;
-    if (dependentTasks > 0) {
-        text += ` and ${output_1.output.bold(dependentTasks)} ${dependentTasks === 1 ? 'task' : 'tasks'} ${projectNames.length === 1 ? 'it depends on' : 'they depend on'}`;
+    if (projectNames.length === 1) {
+        projectsText = `project ${projectNames[0]}`;
     }
-    return text;
+    else {
+        projectsText = `${projectNames.length} projects`;
+    }
+    if (dependentTasks.size > 0) {
+        dependentTasksText = ` and ${output_1.output.bold(dependentTasks.size)} ${dependentTasks.size === 1 ? 'task' : 'tasks'} ${projectNames.length === 1 ? 'it depends on' : 'they depend on'}`;
+    }
+    return `${targetsText} for ${projectsText}${dependentTasksText}`;
 }

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -31,6 +31,9 @@ class TaskHistoryLifeCycle {
     }
     async endCommand() {
         const entries = Array.from(this.taskRuns);
+        if (!this.taskHistory) {
+            return;
+        }
         await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
         const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
         if (flakyTasks.length > 0) {

package/src/tasks-runner/remove-old-cache-records.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
 const path_1 = require("path");
 const WEEK_IN_MS = 1000 * 60 * 60 * 24 * 7;
 const folder = process.argv[2];
@@ -34,11 +33,11 @@ function removeOld(records) {
                 if (time - s.mtimeMs > WEEK_IN_MS) {
                     if (s.isDirectory()) {
                         try {
-                            (0, fs_extra_1.removeSync)(`${r}.commit`);
+                            (0, fs_1.rmSync)(`${r}.commit`, { recursive: true, force: true });
                         }
                         catch (e) { }
                     }
-                    (0, fs_extra_1.removeSync)(r);
+                    (0, fs_1.rmSync)(r, { recursive: true, force: true });
                 }
             }
             catch (e) { }

package/src/tasks-runner/task-orchestrator.d.ts

@@ -4,11 +4,13 @@ import { TaskStatus } from './tasks-runner';
 import { ProjectGraph } from '../config/project-graph';
 import { TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
+import { NxJsonConfiguration } from '../config/nx-json';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
     private readonly projectGraph;
     private readonly taskGraph;
+    private readonly nxJson;
     private readonly options;
     private readonly bail;
     private readonly daemon;
@@ -24,7 +26,7 @@ export declare class TaskOrchestrator {
     private waitingForTasks;
     private groups;
     private bailed;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;

package/src/tasks-runner/task-orchestrator.js

@@ -17,16 +17,17 @@ const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon, outputStyle) {
+    constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.projectGraph = projectGraph;
         this.taskGraph = taskGraph;
+        this.nxJson = nxJson;
         this.options = options;
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
-        this.cache = (0, cache_1.getCache)(this.options);
+        this.cache = (0, cache_1.getCache)(this.nxJson, this.options);
         this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // region internal state

package/src/tasks-runner/tasks-schedule.js

@@ -13,7 +13,7 @@ class TasksSchedule {
         this.notScheduledTaskGraph = this.taskGraph;
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
         this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
-        this.taskHistory = process.env.NX_DISABLE_DB !== 'true' ? (0, task_history_1.getTaskHistory)() : null;
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
         this.scheduledBatches = [];
         this.scheduledTasks = [];
         this.runningTasks = new Set();

package/src/utils/ab-testing.js

@@ -97,7 +97,10 @@ function shouldRecordStats() {
         return true;
     }
     try {
-        const stdout = (0, node_child_process_1.execSync)(pmc.getRegistryUrl, { encoding: 'utf-8' });
+        const stdout = (0, node_child_process_1.execSync)(pmc.getRegistryUrl, {
+            encoding: 'utf-8',
+            windowsHide: true,
+        });
         const url = new URL(stdout.trim());
         // don't record stats when testing locally
         return url.hostname !== 'localhost';