nx 19.8.0-canary.20240917-5b34ea5 → 19.8.0-canary.20240919-7f4a877

package/src/native/index.d.ts

@@ -35,6 +35,7 @@ export declare class NxCache {
   getTaskOutputsPath(hash: string): string
   copyFilesFromCache(cachedResult: CachedResult, outputs: Array<string>): void
   removeOldCacheRecords(): void
+  checkCacheFsInSync(): boolean
 }
 
 export declare class NxTaskHistory {
@@ -96,7 +97,7 @@ export interface CachedResult {
   outputsPath: string
 }
 
-export declare export function connectToNxDb(cacheDir: string, nxVersion: string): ExternalObject<Connection>
+export declare export function connectToNxDb(cacheDir: string, nxVersion: string, dbName?: string | undefined | null): ExternalObject<Connection>
 
 export declare export function copy(src: string, dest: string): void
 

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

@@ -16,10 +16,10 @@ export declare class DbCache {
     private cache;
     private remoteCache;
     private remoteCachePromise;
-    setup(): Promise<void>;
     constructor(options: {
         nxCloudRemoteCache: RemoteCache;
     });
+    init(): Promise<void>;
     get(task: Task): Promise<CachedResult | null>;
     private applyRemoteCacheResults;
     put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
@@ -28,6 +28,10 @@ export declare class DbCache {
     temporaryOutputPath(task: Task): string;
     private getRemoteCache;
     private _getRemoteCache;
+    private getPowerpackS3Cache;
+    private getPowerpackSharedCache;
+    private resolvePackage;
+    private assertCacheIsValid;
 }
 /**
  * @deprecated Use the {@link DbCache} class instead. This will be removed in Nx 21.

package/src/tasks-runner/cache.js

@@ -16,6 +16,7 @@ const nx_cloud_utils_1 = require("../utils/nx-cloud-utils");
 const nx_json_1 = require("../config/nx-json");
 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");
 function getCache(options) {
     return process.env.NX_DISABLE_DB !== 'true' &&
         process.env.NX_DB_CACHE === 'true'
@@ -28,13 +29,17 @@ function getCache(options) {
         : new Cache(options);
 }
 class DbCache {
-    async setup() {
-        this.remoteCache = await this.getRemoteCache();
-    }
     constructor(options) {
         this.options = options;
         this.cache = new native_1.NxCache(workspace_root_1.workspaceRoot, cache_directory_1.cacheDir, (0, db_connection_1.getDbConnection)());
     }
+    async init() {
+        // This should be cheap because we've already loaded
+        this.remoteCache = await this.getRemoteCache();
+        if (!this.remoteCache) {
+            this.assertCacheIsValid();
+        }
+    }
     async get(task) {
         const res = this.cache.get(task.hash);
         if (res) {
@@ -43,7 +48,6 @@ class DbCache {
                 remote: false,
             };
         }
-        await this.setup();
         if (this.remoteCache) {
             // didn't find it locally but we have a remote cache
             // attempt remote cache
@@ -67,9 +71,9 @@ class DbCache {
         return this.cache.applyRemoteCacheResults(hash, res);
     }
     async put(task, terminalOutput, outputs, code) {
+        await this.assertCacheIsValid();
         return tryAndRetry(async () => {
             this.cache.put(task.hash, terminalOutput, outputs, code);
-            await this.setup();
             if (this.remoteCache) {
                 await this.remoteCache.store(task.hash, this.cache.cacheDirectory, terminalOutput, code);
             }
@@ -105,9 +109,51 @@ class DbCache {
             }
         }
         else {
+            return ((await this.getPowerpackS3Cache()) ??
+                (await this.getPowerpackSharedCache()) ??
+                null);
+        }
+    }
+    async getPowerpackS3Cache() {
+        try {
+            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-s3-cache')}`).then(s => require(s));
+            return getRemoteCache();
+        }
+        catch {
             return null;
         }
     }
+    async getPowerpackSharedCache() {
+        try {
+            const { getRemoteCache } = await Promise.resolve(`${this.resolvePackage('@nx/powerpack-shared-cache')}`).then(s => require(s));
+            return getRemoteCache();
+        }
+        catch {
+            return null;
+        }
+    }
+    resolvePackage(pkg) {
+        return require.resolve(pkg, {
+            paths: [process.cwd(), workspace_root_1.workspaceRoot, __dirname],
+        });
+    }
+    assertCacheIsValid() {
+        // User has customized the cache directory - this could be because they
+        // are using a shared cache in the custom directory. The db cache is not
+        // stored in the cache directory, and is keyed by machine ID so they would
+        // hit issues. If we detect this, we can create a fallback db cache in the
+        // custom directory, and check if the entries are there when the main db
+        // cache misses.
+        if ((0, is_ci_1.isCI)() && !this.cache.checkCacheFsInSync()) {
+            const warning = [
+                `Nx found unrecognized artifacts in the cache directory and will not be able to use them.`,
+                `Nx can only restore artifacts it has metadata about.`,
+                `Read about this warning and how to address it here: https://nx.dev/troubleshooting/unknown-local-cache`,
+                ``,
+            ].join('\n');
+            console.warn(warning);
+        }
+    }
 }
 exports.DbCache = DbCache;
 /**

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

@@ -6,7 +6,7 @@ export declare function initTasksRunner(nxArgs: NxArgs): Promise<{
         tasks: Task[];
         parallel: number;
     }) => Promise<{
-        status: number;
+        status: NodeJS.Process["exitCode"];
         taskGraph: TaskGraph;
         taskResults: Record<string, TaskResult>;
     }>;

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

@@ -39,7 +39,7 @@ async function initTasksRunner(nxArgs) {
                     return acc;
                 }, {}),
             };
-            const status = await (0, run_command_1.invokeTasksRunner)({
+            const taskResults = await (0, run_command_1.invokeTasksRunner)({
                 tasks: opts.tasks,
                 projectGraph,
                 taskGraph,
@@ -50,9 +50,11 @@ async function initTasksRunner(nxArgs) {
                 initiatingProject: null,
             });
             return {
-                status,
+                status: Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+                    ? 1
+                    : 0,
                 taskGraph,
-                taskResults: lifeCycle.getTaskResults(),
+                taskResults,
             };
         },
     };

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

@@ -5,11 +5,9 @@ export declare class InvokeRunnerTerminalOutputLifeCycle implements LifeCycle {
     private readonly tasks;
     failedTasks: Task[];
     cachedTasks: Task[];
-    private taskResults;
     constructor(tasks: Task[]);
     startCommand(): void;
     endCommand(): 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,7 +8,6 @@ class InvokeRunnerTerminalOutputLifeCycle {
         this.tasks = tasks;
         this.failedTasks = [];
         this.cachedTasks = [];
-        this.taskResults = {};
     }
     startCommand() {
         output_1.output.log({
@@ -46,7 +45,6 @@ class InvokeRunnerTerminalOutputLifeCycle {
     }
     endTasks(taskResults) {
         for (let t of taskResults) {
-            this.taskResults[t.task.id] = t;
             if (t.status === 'failure') {
                 this.failedTasks.push(t.task);
             }
@@ -65,8 +63,5 @@ 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/life-cycles/static-run-many-terminal-output-life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { TaskStatus } from '../tasks-runner';
-import type { LifeCycle } from '../life-cycle';
+import type { LifeCycle, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 /**
  * The following life cycle's outputs are static, meaning no previous content
@@ -24,10 +24,6 @@ export declare class StaticRunManyTerminalOutputLifeCycle implements LifeCycle {
     startCommand(): void;
     endCommand(): void;
     private skippedTasks;
-    endTasks(taskResults: {
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }[]): void;
+    endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, cacheStatus: TaskStatus, terminalOutput: string): void;
 }

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.d.ts

@@ -1,5 +1,5 @@
 import { TaskStatus } from '../tasks-runner';
-import type { LifeCycle } from '../life-cycle';
+import type { LifeCycle, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 /**
  * The following life cycle's outputs are static, meaning no previous content
@@ -23,10 +23,6 @@ export declare class StaticRunOneTerminalOutputLifeCycle implements LifeCycle {
     });
     startCommand(): void;
     endCommand(): void;
-    endTasks(taskResults: {
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }[]): void;
+    endTasks(taskResults: TaskResult[]): void;
     printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
 }

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.d.ts

@@ -1,6 +1,5 @@
-import { LifeCycle } from '../../tasks-runner/life-cycle';
+import { LifeCycle, TaskResult } from '../../tasks-runner/life-cycle';
 import { Task } from '../../config/task-graph';
-import { TaskStatus } from '../../tasks-runner/tasks-runner';
 export declare class StoreRunInformationLifeCycle implements LifeCycle {
     private readonly command;
     private readonly storeFile;
@@ -10,11 +9,7 @@ export declare class StoreRunInformationLifeCycle implements LifeCycle {
     private taskResults;
     constructor(command?: string, storeFile?: typeof storeFileFunction, now?: () => string);
     startTasks(tasks: Task[]): void;
-    endTasks(taskResults: Array<{
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }>): void;
+    endTasks(taskResults: TaskResult[]): void;
     startCommand(): void;
     endCommand(): any;
 }

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.d.ts

@@ -1,5 +1,4 @@
-import { LifeCycle, TaskMetadata } from '../life-cycle';
-import { TaskStatus } from '../tasks-runner';
+import { LifeCycle, TaskMetadata, TaskResult } from '../life-cycle';
 import { Task } from '../../config/task-graph';
 export declare class TaskProfilingLifeCycle implements LifeCycle {
     private timings;
@@ -8,11 +7,7 @@ export declare class TaskProfilingLifeCycle implements LifeCycle {
     private registeredGroups;
     constructor(_profileFile: string);
     startTasks(tasks: Task[], { groupId }: TaskMetadata): void;
-    endTasks(taskResults: Array<{
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }>, metadata: TaskMetadata): void;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
     endCommand(): void;
     private recordTaskCompletions;
     private registerGroup;

package/src/tasks-runner/life-cycles/task-results-life-cycle.d.ts

@@ -0,0 +1,6 @@
+import type { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskResultsLifeCycle implements LifeCycle {
+    private taskResults;
+    endTasks(taskResults: TaskResult[]): void;
+    getTaskResults(): Record<string, TaskResult>;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskResultsLifeCycle = void 0;
+class TaskResultsLifeCycle {
+    constructor() {
+        this.taskResults = {};
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.taskResults[t.task.id] = t;
+        }
+    }
+    getTaskResults() {
+        return this.taskResults;
+    }
+}
+exports.TaskResultsLifeCycle = TaskResultsLifeCycle;

package/src/tasks-runner/life-cycles/task-timings-life-cycle.d.ts

@@ -1,13 +1,8 @@
 import { Task } from '../../config/task-graph';
-import { LifeCycle } from '../life-cycle';
-import { TaskStatus } from '../tasks-runner';
+import { LifeCycle, TaskResult } from '../life-cycle';
 export declare class TaskTimingsLifeCycle implements LifeCycle {
     private timings;
     startTasks(tasks: Task[]): void;
-    endTasks(taskResults: Array<{
-        task: Task;
-        status: TaskStatus;
-        code: number;
-    }>): void;
+    endTasks(taskResults: TaskResult[]): void;
     endCommand(): void;
 }

package/src/tasks-runner/run-command.d.ts

@@ -3,7 +3,7 @@ import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
 import { Task, TaskGraph } from '../config/task-graph';
 import { TargetDependencyConfig } from '../config/workspace-json-project-json';
 import { NxArgs } from '../utils/command-line-utils';
-import { LifeCycle } from './life-cycle';
+import { LifeCycle, TaskResult } from './life-cycle';
 import { TasksRunner } from './tasks-runner';
 export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
     nxJson: NxJsonConfiguration;
@@ -11,6 +11,14 @@ export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], cur
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<NodeJS.Process['exitCode']>;
+export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+    nxJson: NxJsonConfiguration;
+}, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<{
+    [id: string]: TaskResult;
+}>;
 export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;
@@ -20,7 +28,9 @@ export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, life
     nxArgs: NxArgs;
     loadDotEnvFiles: boolean;
     initiatingProject: string | null;
-}): Promise<1 | 0>;
+}): Promise<{
+    [id: string]: TaskResult;
+}>;
 export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
     tasksRunner: TasksRunner;
     runnerOptions: any;

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
+exports.runCommandForTasks = runCommandForTasks;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
@@ -31,9 +32,11 @@ const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle
 const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
+const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
+const powerpack_1 = require("../utils/powerpack");
 async function getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides) {
     const { runnerOptions } = getRunner(nxArgs, nxJson);
     const isRunOne = initiatingProject != null;
@@ -99,25 +102,32 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
 }
 async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
-        const projectNames = projectsToRun.map((t) => t.name);
-        const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
-        const tasks = Object.values(taskGraph.tasks);
-        const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
-        const status = await invokeTasksRunner({
-            tasks,
-            projectGraph,
-            taskGraph,
-            lifeCycle,
-            nxJson,
-            nxArgs,
-            loadDotEnvFiles: extraOptions.loadDotEnvFiles,
-            initiatingProject,
-        });
-        await renderIsDone;
-        return status;
+        const taskResults = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions);
+        return Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+            ? 1
+            : 0;
     });
     return status;
 }
+async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    const projectNames = projectsToRun.map((t) => t.name);
+    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
+    const tasks = Object.values(taskGraph.tasks);
+    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
+    const taskResults = await invokeTasksRunner({
+        tasks,
+        projectGraph,
+        taskGraph,
+        lifeCycle,
+        nxJson,
+        nxArgs,
+        loadDotEnvFiles: extraOptions.loadDotEnvFiles,
+        initiatingProject,
+    });
+    await renderIsDone;
+    await (0, powerpack_1.printPowerpackLicense)();
+    return taskResults;
+}
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
     if (nxArgs.skipSync) {
@@ -359,9 +369,14 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
     await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
-    const promiseOrObservable = tasksRunner(tasks, {
+    const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
+    const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
+        ...constructLifeCycles(lifeCycle),
+        taskResultsLifecycle,
+    ]);
+    let promiseOrObservable = tasksRunner(tasks, {
         ...runnerOptions,
-        lifeCycle: new life_cycle_1.CompositeLifeCycle(constructLifeCycles(lifeCycle)),
+        lifeCycle: compositedLifeCycle,
     }, {
         initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
         projectGraph,
@@ -418,15 +433,11 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         },
         daemon: client_1.daemonClient,
     });
-    let anyFailures;
     if (promiseOrObservable.subscribe) {
-        anyFailures = await anyFailuresInObservable(promiseOrObservable);
-    }
-    else {
-        // simply await the promise
-        anyFailures = await anyFailuresInPromise(promiseOrObservable);
+        promiseOrObservable = convertObservableToPromise(promiseOrObservable);
     }
-    return anyFailures ? 1 : 0;
+    await promiseOrObservable;
+    return taskResultsLifecycle.getTaskResults();
 }
 function constructLifeCycles(lifeCycle) {
     const lifeCycles = [];
@@ -445,41 +456,23 @@ function constructLifeCycles(lifeCycle) {
     }
     return lifeCycles;
 }
-function mergeTargetDependencies(defaults, deps) {
-    const res = {};
-    Object.keys(defaults ?? {}).forEach((k) => {
-        res[k] = defaults[k].dependsOn;
-    });
-    if (deps) {
-        Object.keys(deps).forEach((k) => {
-            if (res[k]) {
-                res[k] = [...res[k], deps[k]];
-            }
-            else {
-                res[k] = deps[k];
-            }
-        });
-        return res;
-    }
-}
-async function anyFailuresInPromise(promise) {
-    return Object.values(await promise).some((v) => v === 'failure' || v === 'skipped');
-}
-async function anyFailuresInObservable(obs) {
+async function convertObservableToPromise(obs) {
     return await new Promise((res) => {
-        let anyFailures = false;
-        obs.subscribe((t) => {
-            if (!t.success) {
-                anyFailures = true;
-            }
-        }, (error) => {
-            output_1.output.error({
-                title: 'Unhandled error in task executor',
-            });
-            console.error(error);
-            res(true);
-        }, () => {
-            res(anyFailures);
+        let tasksResults = {};
+        obs.subscribe({
+            next: (t) => {
+                tasksResults[t.task.id] = t.success ? 'success' : 'failure';
+            },
+            error: (error) => {
+                output_1.output.error({
+                    title: 'Unhandled error in task executor',
+                });
+                console.error(error);
+                res(tasksResults);
+            },
+            complete: () => {
+                res(tasksResults);
+            },
         });
     });
 }

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

@@ -40,7 +40,6 @@ export declare class TaskOrchestrator {
     private runTaskInForkedProcess;
     private preRunSteps;
     private postRunSteps;
-    private scheduleNextTasks;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;

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

@@ -40,13 +40,14 @@ class TaskOrchestrator {
         this.bailed = false;
     }
     async run() {
-        // Init the ForkedProcessTaskRunner
+        // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
         await Promise.all([
             this.forkedProcessTaskRunner.init(),
             this.tasksSchedule.init(),
+            'init' in this.cache ? this.cache.init() : null,
         ]);
         // initial scheduling
-        await this.scheduleNextTasks();
+        await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
         const threads = [];
         process.stdout.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
@@ -68,6 +69,7 @@ class TaskOrchestrator {
         }
         const doNotSkipCache = this.options.skipNxCache === false ||
             this.options.skipNxCache === undefined;
+        this.processAllScheduledTasks();
         const batch = this.tasksSchedule.nextBatch();
         if (batch) {
             const groupId = this.closeGroup();
@@ -376,15 +378,11 @@ class TaskOrchestrator {
                 status,
             };
         }));
-        await this.scheduleNextTasks();
+        await this.tasksSchedule.scheduleNextTasks();
         // release blocked threads
         this.waitingForTasks.forEach((f) => f(null));
         this.waitingForTasks.length = 0;
     }
-    async scheduleNextTasks() {
-        await this.tasksSchedule.scheduleNextTasks();
-        this.processAllScheduledTasks();
-    }
     complete(taskResults) {
         this.tasksSchedule.complete(taskResults.map(({ taskId }) => taskId));
         for (const { taskId, status } of taskResults) {

package/src/utils/db-connection.d.ts

@@ -1,2 +1,5 @@
 import { ExternalObject } from '../native';
-export declare function getDbConnection(directory?: string): ExternalObject<any>;
+export declare function getDbConnection(opts?: {
+    directory?: string;
+    dbName?: string;
+}): ExternalObject<Connection>;

package/src/utils/db-connection.js

@@ -4,8 +4,19 @@ exports.getDbConnection = getDbConnection;
 const native_1 = require("../native");
 const cache_directory_1 = require("./cache-directory");
 const package_json_1 = require("../../package.json");
-let dbConnection;
-function getDbConnection(directory = cache_directory_1.workspaceDataDirectory) {
-    dbConnection ??= (0, native_1.connectToNxDb)(directory, package_json_1.version);
-    return dbConnection;
+const dbConnectionMap = new Map();
+function getDbConnection(opts = {}) {
+    opts.directory ??= cache_directory_1.workspaceDataDirectory;
+    const key = `${opts.directory}:${opts.dbName ?? 'default'}`;
+    const connection = getEntryOrSet(dbConnectionMap, key, () => (0, native_1.connectToNxDb)(opts.directory, package_json_1.version, opts.dbName));
+    return connection;
+}
+function getEntryOrSet(map, key, defaultValue) {
+    const existing = map.get(key);
+    if (existing) {
+        return existing;
+    }
+    const val = defaultValue();
+    map.set(key, val);
+    return val;
 }

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

@@ -7,6 +7,7 @@ export declare class GitRepository {
     root: string;
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
+    hasUncommittedChanges(): Promise<boolean>;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;
@@ -25,10 +26,11 @@ export declare class GitRepository {
     deleteGitRemote(name: 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>;
+    filterRepo(source: string, destination: string): Promise<void>;
+    filterBranch(source: string, destination: string, branchName: string): Promise<void>;
     private execAsync;
     private quotePath;
+    private quoteArg;
 }
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.