nx 19.6.3 → 19.6.5

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

@@ -4,6 +4,7 @@ exports.getCachedSyncGeneratorChanges = getCachedSyncGeneratorChanges;
 exports.flushSyncGeneratorChangesToDisk = flushSyncGeneratorChangesToDisk;
 exports.collectAndScheduleSyncGenerators = collectAndScheduleSyncGenerators;
 exports.getCachedRegisteredSyncGenerators = getCachedRegisteredSyncGenerators;
+exports._getConflictingGeneratorGroups = _getConflictingGeneratorGroups;
 const nx_json_1 = require("../../config/nx-json");
 const tree_1 = require("../../generators/tree");
 const file_hasher_1 = require("../../hasher/file-hasher");
@@ -24,7 +25,6 @@ let storedNxJsonHash;
 const log = (...messageParts) => {
     logger_1.serverLogger.log('[SYNC]:', ...messageParts);
 };
-// TODO(leo): check conflicts and reuse the Tree where possible
 async function getCachedSyncGeneratorChanges(generators) {
     try {
         log('get sync generators changes on demand', generators);
@@ -36,51 +36,15 @@ async function getCachedSyncGeneratorChanges(generators) {
         }
         // reset the wait time
         waitPeriod = 100;
-        let projects;
-        let errored = false;
-        const getProjectsConfigurations = async () => {
-            if (projects || errored) {
-                return projects;
-            }
-            const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
-            projects = projectGraph
-                ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
-                : null;
-            errored = error !== undefined;
-            return projects;
-        };
-        return (await Promise.all(generators.map(async (generator) => {
-            if (scheduledGenerators.has(generator) ||
-                !syncGeneratorsCacheResultPromises.has(generator)) {
-                // it's scheduled to run (there are pending changes to process) or
-                // it's not scheduled and there's no cached result, so run it
-                const projects = await getProjectsConfigurations();
-                if (projects) {
-                    log(generator, 'already scheduled or not cached, running it now');
-                    runGenerator(generator, projects);
-                }
-                else {
-                    log(generator, 'already scheduled or not cached, project graph errored');
-                    /**
-                     * This should never happen. This is invoked imperatively, and by
-                     * the time it is invoked, the project graph would have already
-                     * been requested. If it errored, it would have been reported and
-                     * this wouldn't have been invoked. We handle it just in case.
-                     *
-                     * Since the project graph would be reported by the relevant
-                     * handlers separately, we just ignore the error, don't cache
-                     * any result and return an empty result, the next time this is
-                     * invoked the process will repeat until it eventually recovers
-                     * when the project graph is fixed.
-                     */
-                    return Promise.resolve({ changes: [], generatorName: generator });
-                }
-            }
-            else {
-                log(generator, 'not scheduled and has cached result, returning cached result');
-            }
-            return syncGeneratorsCacheResultPromises.get(generator);
-        }))).flat();
+        const results = await getFromCacheOrRunGenerators(generators);
+        const conflicts = _getConflictingGeneratorGroups(results);
+        if (!conflicts.length) {
+            // there are no conflicts
+            return results;
+        }
+        // there are conflicts, so we need to re-run the conflicting generators
+        // using the same tree
+        return await processConflictingGenerators(conflicts, results);
     }
     catch (e) {
         console.error(e);
@@ -126,7 +90,7 @@ function collectAndScheduleSyncGenerators(projectGraph) {
         }
         const { projects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
         for (const generator of scheduledGenerators) {
-            runGenerator(generator, projects);
+            syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
         }
         await Promise.all(syncGeneratorsCacheResultPromises.values());
     }, waitPeriod);
@@ -143,6 +107,163 @@ async function getCachedRegisteredSyncGenerators() {
     }
     return [...registeredSyncGenerators];
 }
+async function getFromCacheOrRunGenerators(generators) {
+    let projects;
+    let errored = false;
+    const getProjectsConfigurations = async () => {
+        if (projects || errored) {
+            return projects;
+        }
+        const { projectGraph, error } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+        projects = projectGraph
+            ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+            : null;
+        errored = error !== undefined;
+        return projects;
+    };
+    return (await Promise.all(generators.map(async (generator) => {
+        if (scheduledGenerators.has(generator) ||
+            !syncGeneratorsCacheResultPromises.has(generator)) {
+            // it's scheduled to run (there are pending changes to process) or
+            // it's not scheduled and there's no cached result, so run it
+            const projects = await getProjectsConfigurations();
+            if (projects) {
+                log(generator, 'already scheduled or not cached, running it now');
+                syncGeneratorsCacheResultPromises.set(generator, runGenerator(generator, projects));
+            }
+            else {
+                log(generator, 'already scheduled or not cached, project graph errored');
+                /**
+                 * This should never happen. This is invoked imperatively, and by
+                 * the time it is invoked, the project graph would have already
+                 * been requested. If it errored, it would have been reported and
+                 * this wouldn't have been invoked. We handle it just in case.
+                 *
+                 * Since the project graph would be reported by the relevant
+                 * handlers separately, we just ignore the error, don't cache
+                 * any result and return an empty result, the next time this is
+                 * invoked the process will repeat until it eventually recovers
+                 * when the project graph is fixed.
+                 */
+                return Promise.resolve({ changes: [], generatorName: generator });
+            }
+        }
+        else {
+            log(generator, 'not scheduled and has cached result, returning cached result');
+        }
+        return syncGeneratorsCacheResultPromises.get(generator);
+    }))).flat();
+}
+async function runConflictingGenerators(tree, generators) {
+    const { projectGraph } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
+    const projects = projectGraph
+        ? (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects
+        : null;
+    if (!projects) {
+        /**
+         * This should never happen. This is invoked imperatively, and by
+         * the time it is invoked, the project graph would have already
+         * been requested. If it errored, it would have been reported and
+         * this wouldn't have been invoked. We handle it just in case.
+         *
+         * Since the project graph would be reported by the relevant
+         * handlers separately, we just ignore the error.
+         */
+        return generators.map((generator) => ({
+            changes: [],
+            generatorName: generator,
+        }));
+    }
+    // we need to run conflicting generators sequentially because they use the same tree
+    const results = [];
+    for (const generator of generators) {
+        log(generator, 'running it now');
+        results.push(await runGenerator(generator, projects, tree));
+    }
+    return results;
+}
+async function processConflictingGenerators(conflicts, initialResults) {
+    const conflictRunResults = (await Promise.all(conflicts.map((generators) => {
+        const [firstGenerator, ...generatorsToRun] = generators;
+        // it must exists because the conflicts were identified from the initial results
+        const firstGeneratorResult = initialResults.find((r) => r.generatorName === firstGenerator);
+        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generators ${generators.join(',')}`);
+        // pre-apply the changes from the first generator to avoid running it
+        for (const change of firstGeneratorResult.changes) {
+            if (change.type === 'CREATE' || change.type === 'UPDATE') {
+                tree.write(change.path, change.content, change.options);
+            }
+            else if (change.type === 'DELETE') {
+                tree.delete(change.path);
+            }
+        }
+        /**
+         * We don't cache the results of conflicting generators because they
+         * use the same tree, so some files might contain results from multiple
+         * generators and we don't have guarantees that the same combination of
+         * generators will run together.
+         */
+        return runConflictingGenerators(tree, generatorsToRun);
+    }))).flat();
+    /**
+     * The order of the results from the re-run generators is important because
+     * the last result from a group of conflicting generators will contain the
+     * changes from the previous conflicting generators. So, instead of replacing
+     * in-place the initial results, we first add the results from the re-run
+     * generators, and then add the initial results that were not from a
+     * conflicting generator.
+     */
+    const results = [...conflictRunResults];
+    for (const result of initialResults) {
+        if (conflictRunResults.every((r) => r.generatorName !== result.generatorName)) {
+            // this result is not from a conflicting generator, so we add it to the
+            // results
+            results.push(result);
+        }
+    }
+    return results;
+}
+/**
+ * @internal
+ */
+function _getConflictingGeneratorGroups(results) {
+    const changedFileToGeneratorMap = new Map();
+    for (const result of results) {
+        for (const change of result.changes) {
+            if (!changedFileToGeneratorMap.has(change.path)) {
+                changedFileToGeneratorMap.set(change.path, new Set());
+            }
+            changedFileToGeneratorMap.get(change.path).add(result.generatorName);
+        }
+    }
+    const conflicts = [];
+    for (const generatorSet of changedFileToGeneratorMap.values()) {
+        if (generatorSet.size === 1) {
+            // no conflicts
+            continue;
+        }
+        if (conflicts.length === 0) {
+            // there are no conflicts yet, so we just add the first group
+            conflicts.push(new Set(generatorSet));
+            continue;
+        }
+        // identify if any of the current generator sets intersect with any of the
+        // existing conflict groups
+        const generatorsArray = Array.from(generatorSet);
+        const existingConflictGroup = conflicts.find((group) => generatorsArray.some((generator) => group.has(generator)));
+        if (existingConflictGroup) {
+            // there's an intersecting group, so we merge the two
+            for (const generator of generatorsArray) {
+                existingConflictGroup.add(generator);
+            }
+        }
+        else {
+            // there's no intersecting group, so we create a new one
+            conflicts.push(new Set(generatorsArray));
+        }
+    }
+    return conflicts.map((group) => Array.from(group));
+}
 function collectAllRegisteredSyncGenerators(projectGraph) {
     const projectGraphHash = hashProjectGraph(projectGraph);
     if (storedProjectGraphHash !== projectGraphHash) {
@@ -183,16 +304,15 @@ function collectAllRegisteredSyncGenerators(projectGraph) {
         }
     }
 }
-function runGenerator(generator, projects) {
+function runGenerator(generator, projects, tree) {
     log('running scheduled generator', generator);
     // remove it from the scheduled set
     scheduledGenerators.delete(generator);
-    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
-    // run the generator and cache the result
-    syncGeneratorsCacheResultPromises.set(generator, (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
+    tree ??= new tree_1.FsTree(workspace_root_1.workspaceRoot, false, `running sync generator ${generator}`);
+    return (0, sync_generators_1.runSyncGenerator)(tree, generator, projects).then((result) => {
         log(generator, 'changes:', result.changes.map((c) => c.path).join(', '));
         return result;
-    }));
+    });
 }
 function hashProjectGraph(projectGraph) {
     const stringifiedProjects = Object.entries(projectGraph.nodes)

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

@@ -16,7 +16,7 @@ let pseudoTerminal;
 const childProcesses = new Set();
 function loadEnvVarsFile(path, env = {}) {
     (0, task_env_1.unloadDotEnvFile)(path, env);
-    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env, true);
     if (result.error) {
         throw result.error;
     }
@@ -293,14 +293,19 @@ function calculateCwd(cwd, context) {
 }
 function processEnv(color, cwd, env, envFile) {
     const localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
-    const res = {
+    let res = {
         ...process.env,
         ...localEnv,
-        ...env,
     };
+    // env file from envFile option takes priority over process env
     if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false') {
         loadEnvVars(envFile, res);
     }
+    // env variables from env option takes priority over everything else
+    res = {
+        ...res,
+        ...env,
+    };
     // need to override PATH to make sure we are using the local node_modules
     if (localEnv.PATH)
         res.PATH = localEnv.PATH; // UNIX-like

package/src/hasher/node-task-hasher-impl.d.ts

@@ -38,7 +38,7 @@ export declare class NodeTaskHasherImpl implements TaskHasherImpl {
     private findExternalDependencyNodeName;
     private hashSingleProjectInputs;
     private hashProjectInputs;
-    private hashRootFileset;
+    private hashRootFilesets;
     private hashProjectConfig;
     private hashTsConfig;
     private hashProjectFileset;

package/src/hasher/node-task-hasher-impl.js

@@ -299,10 +299,10 @@ class NodeTaskHasherImpl {
             this.hashProjectFileset(projectName, projectFilesets),
             this.hashProjectConfig(projectName),
             this.hashTsConfig(projectName),
-            ...[
-                ...workspaceFilesets,
-                ...this.legacyFilesetInputs.map((r) => r.fileset),
-            ].map((fileset) => this.hashRootFileset(fileset)),
+            ...(workspaceFilesets.length
+                ? [this.hashRootFilesets(workspaceFilesets)]
+                : []),
+            this.hashRootFilesets(this.legacyFilesetInputs.map((r) => r.fileset)),
             ...[...notFilesets, ...this.legacyRuntimeInputs].map((r) => r['runtime']
                 ? this.hashRuntime(env, r['runtime'])
                 : this.hashEnv(env, r['env'])),
@@ -320,22 +320,40 @@ class NodeTaskHasherImpl {
         }
         return Promise.all(partialHashes).then((hashes) => hashes.flat());
     }
-    async hashRootFileset(fileset) {
-        const mapKey = fileset;
-        const withoutWorkspaceRoot = fileset.substring(16);
+    async hashRootFilesets(filesets) {
+        const mapKey = `workspace:[${filesets.join(',')}]`;
         if (!this.filesetHashes[mapKey]) {
             this.filesetHashes[mapKey] = new Promise(async (res) => {
                 const parts = [];
-                const matchingFile = this.allWorkspaceFiles.find((t) => t.file === withoutWorkspaceRoot);
-                if (matchingFile) {
-                    parts.push(matchingFile.hash);
+                const negativePatterns = [];
+                const positivePatterns = [];
+                for (const fileset of filesets) {
+                    if (fileset.startsWith('!')) {
+                        negativePatterns.push(fileset.substring(17));
+                    }
+                    else {
+                        positivePatterns.push(fileset.substring(16));
+                    }
                 }
-                else {
-                    this.allWorkspaceFiles
-                        .filter((f) => (0, minimatch_1.minimatch)(f.file, withoutWorkspaceRoot))
-                        .forEach((f) => {
-                        parts.push(f.hash);
-                    });
+                for (const fileset of positivePatterns) {
+                    const withoutWorkspaceRoot = fileset;
+                    // Used to shortcut minimatch if not necessary
+                    const matchingFile = this.allWorkspaceFiles.find((t) => t.file === withoutWorkspaceRoot);
+                    // shortcut because there is a direct match
+                    if (matchingFile) {
+                        if (!negativePatterns.some((p) => (0, minimatch_1.minimatch)(matchingFile.file, p))) {
+                            parts.push(matchingFile.hash);
+                        }
+                        // No direct match, check if pattern matched
+                    }
+                    else {
+                        this.allWorkspaceFiles
+                            .filter((f) => (0, minimatch_1.minimatch)(f.file, withoutWorkspaceRoot) &&
+                            !negativePatterns.some((p) => (0, minimatch_1.minimatch)(f.file, p)))
+                            .forEach((f) => {
+                            parts.push(f.hash);
+                        });
+                    }
                 }
                 const value = (0, file_hasher_1.hashArray)(parts);
                 res({

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -18,6 +18,13 @@ const defaultNpmResolutionCache = new Map();
 const builtInModuleSet = new Set([
     ...node_module_1.builtinModules,
     ...node_module_1.builtinModules.map((x) => `node:${x}`),
+    // These are missing in the builtinModules list
+    // See: https://github.com/nodejs/node/issues/42785
+    // TODO(v20): We should be safe to use `isBuiltin` function instead of keep the set here (https://nodejs.org/api/module.html#moduleisbuiltinmodulename)
+    'test',
+    'node:test',
+    'node:sea',
+    'node:sqlite',
 ]);
 function isBuiltinModuleImport(importExpr) {
     const packageName = (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(importExpr);
@@ -265,7 +272,7 @@ class TargetProjectLocator {
             // Resolve the main entry point of the package
             const pathOfFileInPackage = packageJsonPath ?? (0, resolve_relative_to_dir_1.resolveRelativeToDir)(packageName, relativeToDir);
             let dir = (0, node_path_1.dirname)(pathOfFileInPackage);
-            while (dir !== (0, node_path_1.parse)(dir).root) {
+            while (dir !== (0, node_path_1.dirname)(dir)) {
                 const packageJsonPath = (0, node_path_1.join)(dir, 'package.json');
                 try {
                     const parsedPackageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);

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

@@ -273,7 +273,7 @@ async function startPluginWorker() {
                     socket,
                 });
             }
-            else if (attempts > 1000) {
+            else if (attempts > 10000) {
                 // daemon fails to start, the process probably exited
                 // we print the logs and exit the client
                 reject('Failed to start plugin worker.');

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

@@ -23,7 +23,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);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.projectGraph, context.taskGraph, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.outputStyle);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

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

@@ -1,5 +1,6 @@
 import { NxArgs } from '../utils/command-line-utils';
 import { Task, TaskGraph } from '../config/task-graph';
+import { TaskResult } from './life-cycle';
 export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
     invoke: (opts: {
         tasks: Task[];
@@ -7,5 +8,6 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
     }) => Promise<{
         status: number;
         taskGraph: TaskGraph;
+        taskResults: Record<string, TaskResult>;
     }>;
 }>;

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

@@ -52,6 +52,7 @@ async function initTasksRunner(nxArgs) {
             return {
                 status,
                 taskGraph,
+                taskResults: lifeCycle.getTaskResults(),
             };
         },
     };

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.d.ts

@@ -1,17 +1,15 @@
 import { TaskStatus } from '../tasks-runner';
-import type { LifeCycle } from '../life-cycle';
+import type { LifeCycle, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 export declare class InvokeRunnerTerminalOutputLifeCycle implements LifeCycle {
     private readonly tasks;
     failedTasks: Task[];
     cachedTasks: Task[];
+    private taskResults;
     constructor(tasks: Task[]);
     startCommand(): void;
     endCommand(): void;
-    endTasks(taskResults: {
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }[]): void;
+    endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
+    getTaskResults(): Record<string, TaskResult>;
 }

package/src/tasks-runner/life-cycles/invoke-runner-terminal-output-life-cycle.js

@@ -8,6 +8,7 @@ class InvokeRunnerTerminalOutputLifeCycle {
         this.tasks = tasks;
         this.failedTasks = [];
         this.cachedTasks = [];
+        this.taskResults = {};
     }
     startCommand() {
         output_1.output.log({
@@ -45,6 +46,7 @@ class InvokeRunnerTerminalOutputLifeCycle {
     }
     endTasks(taskResults) {
         for (let t of taskResults) {
+            this.taskResults[t.task.id] = t;
             if (t.status === 'failure') {
                 this.failedTasks.push(t.task);
             }
@@ -63,5 +65,8 @@ class InvokeRunnerTerminalOutputLifeCycle {
         const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
         output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
     }
+    getTaskResults() {
+        return this.taskResults;
+    }
 }
 exports.InvokeRunnerTerminalOutputLifeCycle = InvokeRunnerTerminalOutputLifeCycle;

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

@@ -7,9 +7,9 @@ export declare function getEnvVariablesForTask(task: Task, taskSpecificEnv: Node
 };
 /**
  * This function loads a .env file and expands the variables in it.
- * It is going to override existing environmentVariables.
- * @param filename
- * @param environmentVariables
+ * @param filename the .env file to load
+ * @param environmentVariables the object to load environment variables into
+ * @param override whether to override existing environment variables
  */
 export declare function loadAndExpandDotEnvFile(filename: string, environmentVariables: NodeJS.ProcessEnv, override?: boolean): import("dotenv-expand").DotenvExpandOutput;
 /**

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

@@ -79,9 +79,9 @@ function getNxEnvVariablesForTask(task, forceColor, skipNxCache, captureStderr,
 }
 /**
  * This function loads a .env file and expands the variables in it.
- * It is going to override existing environmentVariables.
- * @param filename
- * @param environmentVariables
+ * @param filename the .env file to load
+ * @param environmentVariables the object to load environment variables into
+ * @param override whether to override existing environment variables
  */
 function loadAndExpandDotEnvFile(filename, environmentVariables, override = false) {
     const myEnv = (0, dotenv_1.config)({

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

@@ -12,6 +12,7 @@ export declare class TaskOrchestrator {
     private readonly options;
     private readonly bail;
     private readonly daemon;
+    private readonly outputStyle;
     private cache;
     private forkedProcessTaskRunner;
     private tasksSchedule;
@@ -23,7 +24,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);
+    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
     run(): Promise<{
         [id: string]: TaskStatus;
     }>;

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

@@ -17,7 +17,7 @@ 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) {
+    constructor(hasher, initiatingProject, projectGraph, taskGraph, options, bail, daemon, outputStyle) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.projectGraph = projectGraph;
@@ -25,6 +25,7 @@ class TaskOrchestrator {
         this.options = options;
         this.bail = bail;
         this.daemon = daemon;
+        this.outputStyle = outputStyle;
         this.cache = new cache_1.Cache(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);
@@ -200,7 +201,9 @@ class TaskOrchestrator {
         const pipeOutput = await this.pipeOutputCapture(task);
         // obtain metadata
         const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
+        const streamOutput = this.outputStyle === 'static'
+            ? false
+            : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
         let env = pipeOutput
             ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, process.env.FORCE_COLOR === undefined
                 ? 'true'

package/src/utils/git-utils.d.ts

@@ -1,6 +1,6 @@
-import { ExecSyncOptions } from 'child_process';
-export declare function cloneFromUpstream(url: string, destination: string, { originName }?: {
+export declare function cloneFromUpstream(url: string, destination: string, { originName, depth }?: {
     originName: string;
+    depth?: number;
 }): Promise<GitRepository>;
 export declare class GitRepository {
     private directory;
@@ -8,12 +8,10 @@ export declare class GitRepository {
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
-    private execAsync;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;
     getGitFiles(path: string): Promise<string[]>;
     reset(ref: string): Promise<string>;
-    squashLastTwoCommits(): Promise<string>;
     mergeUnrelatedHistories(ref: string, message: string): Promise<string>;
     fetch(remote: string, ref?: string): Promise<string>;
     checkout(branch: string, opts: {
@@ -25,14 +23,13 @@ export declare class GitRepository {
     commit(message: string): Promise<string>;
     amendCommit(): Promise<string>;
     deleteGitRemote(name: string): Promise<string>;
-    deleteBranch(branch: string): Promise<string>;
     addGitRemote(name: string, url: string): Promise<string>;
+    hasFilterRepoInstalled(): Promise<boolean>;
+    filterRepo(subdirectory: string): Promise<string>;
+    filterBranch(subdirectory: string, branchName: string): Promise<string>;
+    private execAsync;
+    private quotePath;
 }
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-export declare function updateRebaseFile(contents: string): string;
-export declare function fetchGitRemote(name: string, branch: string, execOptions: ExecSyncOptions): string | Buffer;
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */