nx 19.7.4 → 19.8.0-beta.1

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.js

@@ -41,7 +41,10 @@ class TaskOrchestrator {
     }
     async run() {
         // Init the ForkedProcessTaskRunner
-        await this.forkedProcessTaskRunner.init();
+        await Promise.all([
+            this.forkedProcessTaskRunner.init(),
+            this.tasksSchedule.init(),
+        ]);
         // initial scheduling
         await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');

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

@@ -12,12 +12,15 @@ export declare class TasksSchedule {
     private notScheduledTaskGraph;
     private reverseTaskDeps;
     private reverseProjectGraph;
+    private taskHistory;
     private scheduledBatches;
     private scheduledTasks;
     private runningTasks;
     private completedTasks;
     private scheduleRequestsExecutionChain;
+    private estimatedTaskTimings;
     constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
+    init(): Promise<void>;
     scheduleNextTasks(): Promise<void>;
     hasTasks(): boolean;
     complete(taskIds: string[]): void;

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

@@ -4,6 +4,7 @@ exports.TasksSchedule = void 0;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const operators_1 = require("../project-graph/operators");
+const task_history_1 = require("../utils/task-history");
 class TasksSchedule {
     constructor(projectGraph, taskGraph, options) {
         this.projectGraph = projectGraph;
@@ -12,11 +13,19 @@ 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.scheduledBatches = [];
         this.scheduledTasks = [];
         this.runningTasks = new Set();
         this.completedTasks = new Set();
         this.scheduleRequestsExecutionChain = Promise.resolve();
+        this.estimatedTaskTimings = {};
+    }
+    async init() {
+        if (this.taskHistory) {
+            this.estimatedTaskTimings =
+                await this.taskHistory.getEstimatedTaskTimings(Object.values(this.taskGraph.tasks).map((t) => t.target));
+        }
     }
     async scheduleNextTasks() {
         this.scheduleRequestsExecutionChain =
@@ -81,10 +90,23 @@ class TasksSchedule {
             // Most likely tasks with no dependencies such as test
             const project1 = this.taskGraph.tasks[taskId1].target.project;
             const project2 = this.taskGraph.tasks[taskId2].target.project;
-            return ((0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph)
-                .length -
-                (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph)
-                    .length);
+            const project1NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph).length;
+            const project2NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph).length;
+            const dependenciesDiff = project2NodeDependencies - project1NodeDependencies;
+            if (dependenciesDiff !== 0) {
+                return dependenciesDiff;
+            }
+            const task1Timing = this.estimatedTaskTimings[taskId1];
+            if (!task1Timing) {
+                // if no timing or 0, put task1 at beginning
+                return -1;
+            }
+            const task2Timing = this.estimatedTaskTimings[taskId2];
+            if (!task2Timing) {
+                // if no timing or 0, put task2 at beginning
+                return 1;
+            }
+            return task2Timing - task1Timing;
         });
         this.runningTasks.add(taskId);
     }

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[]>;

package/src/utils/git-utils.js

@@ -40,6 +40,10 @@ class GitRepository {
             .toString()
             .trim();
     }
+    async hasUncommittedChanges() {
+        const data = await this.execAsync(`git status --porcelain`);
+        return data.trim() !== '';
+    }
     async addFetchRemote(remoteName, branch) {
         return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
     }

package/src/utils/plugins/output.d.ts

@@ -2,4 +2,5 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PluginCapabilities } from './plugin-capabilities';
 export declare function listPlugins(plugins: Map<string, PluginCapabilities>, title: string): void;
 export declare function listAlsoAvailableCorePlugins(installedPlugins: Map<string, PluginCapabilities>): void;
+export declare function listPowerpackPlugins(): void;
 export declare function listPluginCapabilities(pluginName: string, projects: Record<string, ProjectConfiguration>): Promise<void>;

package/src/utils/plugins/output.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.listPlugins = listPlugins;
 exports.listAlsoAvailableCorePlugins = listAlsoAvailableCorePlugins;
+exports.listPowerpackPlugins = listPowerpackPlugins;
 exports.listPluginCapabilities = listPluginCapabilities;
 const chalk = require("chalk");
 const output_1 = require("../output");
@@ -45,6 +46,12 @@ function listAlsoAvailableCorePlugins(installedPlugins) {
         });
     }
 }
+function listPowerpackPlugins() {
+    const powerpackLink = 'https://nx.dev/plugin-registry';
+    output_1.output.log({
+        title: `Available Powerpack Plugins: ${powerpackLink}`,
+    });
+}
 async function listPluginCapabilities(pluginName, projects) {
     const plugin = await (0, plugin_capabilities_1.getPluginCapabilities)(workspace_root_1.workspaceRoot, pluginName, projects);
     if (!plugin) {

package/src/utils/powerpack.d.ts

@@ -0,0 +1,5 @@
+export declare function printPowerpackLicense(): Promise<void>;
+export declare function getPowerpackLicenseInformation(): Promise<any>;
+export declare class NxPowerpackNotInstalledError extends Error {
+    constructor(e: Error);
+}

package/src/utils/powerpack.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NxPowerpackNotInstalledError = void 0;
+exports.printPowerpackLicense = printPowerpackLicense;
+exports.getPowerpackLicenseInformation = getPowerpackLicenseInformation;
+const logger_1 = require("./logger");
+const package_manager_1 = require("./package-manager");
+const workspace_root_1 = require("./workspace-root");
+async function printPowerpackLicense() {
+    try {
+        const { organizationName, seatCount, workspaceCount } = await getPowerpackLicenseInformation();
+        logger_1.logger.log(`Nx Powerpack Licensed to ${organizationName} for ${seatCount} user${seatCount > 1 ? '' : 's'} in ${workspaceCount} workspace${workspaceCount > 1 ? '' : 's'}`);
+    }
+    catch { }
+}
+async function getPowerpackLicenseInformation() {
+    try {
+        const { getPowerpackLicenseInformation } = (await Promise.resolve().then(() => require(
+        // @ts-ignore
+        '@nx/powerpack-license'
+        // TODO(@FrozenPandaz): Provide the right type here.
+        )));
+        // )) as typeof import('@nx/powerpack-license');
+        return getPowerpackLicenseInformation(workspace_root_1.workspaceRoot);
+    }
+    catch (e) {
+        if ('code' in e && e.code === 'ERR_MODULE_NOT_FOUND') {
+            throw new NxPowerpackNotInstalledError(e);
+        }
+        throw e;
+    }
+}
+class NxPowerpackNotInstalledError extends Error {
+    constructor(e) {
+        super(`The "@nx/powerpack-license" package is needed to use Nx Powerpack enabled features. Please install the @nx/powerpack-license with ${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/powerpack-license`, { cause: e });
+    }
+}
+exports.NxPowerpackNotInstalledError = NxPowerpackNotInstalledError;

package/src/utils/task-history.d.ts

@@ -1,6 +1,17 @@
-import { NxTaskHistory, TaskRun } from '../native';
+import { NxTaskHistory, TaskRun, TaskTarget } from '../native';
 export declare class TaskHistory {
     taskHistory: NxTaskHistory;
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    getEstimatedTaskTimings(targets: TaskTarget[]): Promise<Record<string, number>>;
     getFlakyTasks(hashes: string[]): Promise<string[]>;
     recordTaskRuns(taskRuns: TaskRun[]): Promise<void>;
 }
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory
+ */
+export declare function getTaskHistory(): TaskHistory;

package/src/utils/task-history.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskHistory = void 0;
+exports.getTaskHistory = getTaskHistory;
 const client_1 = require("../daemon/client/client");
 const is_on_daemon_1 = require("../daemon/is-on-daemon");
 const native_1 = require("../native");
@@ -9,6 +10,17 @@ class TaskHistory {
     constructor() {
         this.taskHistory = new native_1.NxTaskHistory((0, db_connection_1.getDbConnection)());
     }
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    async getEstimatedTaskTimings(targets) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.getEstimatedTaskTimings(targets);
+        }
+        return await client_1.daemonClient.getEstimatedTaskTimings(targets);
+    }
     async getFlakyTasks(hashes) {
         if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
             return this.taskHistory.getFlakyTasks(hashes);
@@ -23,3 +35,14 @@ class TaskHistory {
     }
 }
 exports.TaskHistory = TaskHistory;
+let taskHistory;
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory
+ */
+function getTaskHistory() {
+    if (!taskHistory) {
+        taskHistory = new TaskHistory();
+    }
+    return taskHistory;
+}