@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,25 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { NxArgs } from '../utils/command-line-utils';
+import { TaskHasher } from '../hasher/task-hasher';
+import { DaemonClient } from '../daemon/client/client';
+export type TaskStatus = 'success' | 'failure' | 'skipped' | 'local-cache-kept-existing' | 'local-cache' | 'remote-cache';
+/**
+ * `any | Promise<{ [id: string]: TaskStatus }>`
+ * will change to Promise<{ [id: string]: TaskStatus }> after Nx 15 is released.
+ */
+export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
+    target?: string;
+    initiatingProject?: string | null;
+    initiatingTasks: Task[];
+    projectGraph: ProjectGraph;
+    nxJson: NxJsonConfiguration;
+    nxArgs: NxArgs;
+    taskGraph?: TaskGraph;
+    hasher?: TaskHasher;
+    daemon?: DaemonClient;
+}) => any | Promise<{
+    [id: string]: TaskStatus;
+}>;
+//# sourceMappingURL=tasks-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-runner.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/tasks-runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,MAAM,MAAM,UAAU,GAClB,SAAS,GACT,SAAS,GACT,SAAS,GACT,2BAA2B,GAC3B,aAAa,GACb,cAAc,CAAC;AAEnB;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,CACrC,KAAK,EAAE,IAAI,EAAE,EACb,OAAO,EAAE,CAAC,EACV,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAClC,eAAe,EAAE,IAAI,EAAE,CAAC;IACxB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,mBAAmB,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB,KACE,GAAG,GAAG,OAAO,CAAC;IAAE,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,CAAA;CAAE,CAAC,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,46 @@
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { Task, TaskGraph } from '../config/task-graph';
+import { ProjectGraph } from '../config/project-graph';
+export interface Batch {
+    id: string;
+    executorName: string;
+    taskGraph: TaskGraph;
+}
+export declare class TasksSchedule {
+    private readonly projectGraph;
+    private readonly taskGraph;
+    private readonly options;
+    private notScheduledTaskGraph;
+    private reverseTaskDeps;
+    private reverseProjectGraph;
+    private taskHistory;
+    private scheduledBatches;
+    private scheduledTasks;
+    private runningTasks;
+    private completedTasks;
+    private scheduleRequestsExecutionChain;
+    private estimatedTaskTimings;
+    private projectDependencies;
+    private batchCounters;
+    constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
+    init(): Promise<void>;
+    scheduleNextTasks(): Promise<void>;
+    hasTasks(): boolean;
+    complete(taskIds: string[]): void;
+    getAllScheduledTasks(): {
+        scheduledTasks: string[];
+        scheduledBatches: Batch[];
+    };
+    nextTask(): Task;
+    nextBatch(): Batch;
+    getIncompleteTasks(): Task[];
+    private scheduleTasks;
+    private scheduleTask;
+    private scheduleBatches;
+    private scheduleBatch;
+    private processTaskForBatches;
+    private canBatchTaskBeScheduled;
+    private canBeScheduled;
+    getEstimatedTaskTimings(): Record<string, number>;
+}
+//# sourceMappingURL=tasks-schedule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tasks-schedule.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/tasks-schedule.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAKvD,MAAM,WAAW,KAAK;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC;CACtB;AAED,qBAAa,aAAa;IAgBtB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAjB1B,OAAO,CAAC,qBAAqB,CAAkB;IAC/C,OAAO,CAAC,eAAe,CAAwC;IAC/D,OAAO,CAAC,mBAAmB,CAA8B;IACzD,OAAO,CAAC,WAAW,CAAwC;IAE3D,OAAO,CAAC,gBAAgB,CAAe;IACvC,OAAO,CAAC,cAAc,CAAgB;IACtC,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,8BAA8B,CAAqB;IAC3D,OAAO,CAAC,oBAAoB,CAA8B;IAC1D,OAAO,CAAC,mBAAmB,CAA8B;IACzD,OAAO,CAAC,aAAa,CAA8B;gBAGhC,YAAY,EAAE,YAAY,EAC1B,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,yBAAyB;IAGxC,IAAI;IAkBJ,iBAAiB;IAMvB,QAAQ;IASR,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE;IAW1B,oBAAoB;;;;IAOpB,QAAQ;IAQR,SAAS,IAAI,KAAK;IAMlB,kBAAkB,IAAI,IAAI,EAAE;YAUrB,aAAa;YAWb,YAAY;YAkDZ,eAAe;IAkB7B,OAAO,CAAC,aAAa;YAiBP,qBAAqB;IA+DnC,OAAO,CAAC,uBAAuB;IAc/B,OAAO,CAAC,cAAc;IAiCf,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAGzD"}

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

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;
+        this.taskGraph = taskGraph;
+        this.options = options;
+        this.notScheduledTaskGraph = this.taskGraph;
+        this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
+        this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
+        this.scheduledBatches = [];
+        this.scheduledTasks = [];
+        this.runningTasks = new Set();
+        this.completedTasks = new Set();
+        this.scheduleRequestsExecutionChain = Promise.resolve();
+        this.estimatedTaskTimings = {};
+        this.projectDependencies = {};
+        this.batchCounters = {};
+    }
+    async init() {
+        if (this.taskHistory) {
+            this.estimatedTaskTimings =
+                await this.taskHistory.getEstimatedTaskTimings(Object.values(this.taskGraph.tasks).map((t) => t.target));
+        }
+        for (const project of Object.values(this.taskGraph.tasks).map((t) => t.target.project)) {
+            this.projectDependencies[project] ??= (0, project_graph_utils_1.findAllProjectNodeDependencies)(project, this.reverseProjectGraph).length;
+        }
+    }
+    async scheduleNextTasks() {
+        this.scheduleRequestsExecutionChain =
+            this.scheduleRequestsExecutionChain.then(() => this.scheduleTasks());
+        await this.scheduleRequestsExecutionChain;
+    }
+    hasTasks() {
+        return (this.scheduledBatches.length +
+            this.scheduledTasks.length +
+            Object.keys(this.notScheduledTaskGraph.tasks).length !==
+            0);
+    }
+    complete(taskIds) {
+        for (const taskId of taskIds) {
+            this.completedTasks.add(taskId);
+            this.runningTasks.delete(taskId);
+        }
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, taskIds);
+    }
+    getAllScheduledTasks() {
+        return {
+            scheduledTasks: this.scheduledTasks,
+            scheduledBatches: this.scheduledBatches,
+        };
+    }
+    nextTask() {
+        if (this.scheduledTasks.length > 0) {
+            return this.taskGraph.tasks[this.scheduledTasks.shift()];
+        }
+        else {
+            return null;
+        }
+    }
+    nextBatch() {
+        return this.scheduledBatches.length > 0
+            ? this.scheduledBatches.shift()
+            : null;
+    }
+    getIncompleteTasks() {
+        const incompleteTasks = [];
+        for (const taskId in this.taskGraph.tasks) {
+            if (!this.completedTasks.has(taskId)) {
+                incompleteTasks.push(this.taskGraph.tasks[taskId]);
+            }
+        }
+        return incompleteTasks;
+    }
+    async scheduleTasks() {
+        if (this.options.batch || process.env.NX_BATCH_MODE === 'true') {
+            await this.scheduleBatches();
+        }
+        for (let root of this.notScheduledTaskGraph.roots) {
+            if (this.canBeScheduled(root)) {
+                await this.scheduleTask(root);
+            }
+        }
+    }
+    async scheduleTask(taskId) {
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, [taskId]);
+        this.scheduledTasks = this.scheduledTasks
+            .concat(taskId)
+            // NOTE: sort task by most dependent on first
+            .sort((taskId1, taskId2) => {
+            // First compare the length of task dependencies.
+            const taskDifference = this.reverseTaskDeps[taskId2].length -
+                this.reverseTaskDeps[taskId1].length;
+            if (taskDifference !== 0) {
+                return taskDifference;
+            }
+            // Tie-breaker for tasks with equal number of task dependencies.
+            // 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;
+            const project1NodeDependencies = this.projectDependencies[project1];
+            const project2NodeDependencies = this.projectDependencies[project2];
+            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);
+    }
+    async scheduleBatches() {
+        const batchMap = {};
+        for (const root of this.notScheduledTaskGraph.roots) {
+            const rootTask = this.notScheduledTaskGraph.tasks[root];
+            const executorName = (0, utils_1.getExecutorNameForTask)(rootTask, this.projectGraph);
+            await this.processTaskForBatches(batchMap, rootTask, executorName, true, new Set());
+        }
+        for (const [executorName, taskGraph] of Object.entries(batchMap)) {
+            this.scheduleBatch(executorName, taskGraph);
+        }
+    }
+    scheduleBatch(executorName, taskGraph) {
+        // Generate batch ID with incrementing counter
+        if (!this.batchCounters[executorName]) {
+            this.batchCounters[executorName] = 0;
+        }
+        this.batchCounters[executorName]++;
+        const batchId = `${executorName} ${this.batchCounters[executorName]}`;
+        // Create a new task graph without the tasks that are being scheduled as part of this batch
+        this.notScheduledTaskGraph = (0, utils_1.removeTasksFromTaskGraph)(this.notScheduledTaskGraph, Object.keys(taskGraph.tasks));
+        this.scheduledBatches.push({ id: batchId, executorName, taskGraph });
+    }
+    async processTaskForBatches(batches, task, rootExecutorName, isRoot, visitedInBatch) {
+        // Skip if already processed in this batch - prevents redundant traversals
+        if (visitedInBatch.has(task.id)) {
+            return;
+        }
+        if (!this.canBatchTaskBeScheduled(task, batches[rootExecutorName])) {
+            return;
+        }
+        const { batchImplementationFactory } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
+        const executorName = (0, utils_1.getExecutorNameForTask)(task, this.projectGraph);
+        if (rootExecutorName !== executorName) {
+            return;
+        }
+        if (!batchImplementationFactory) {
+            return;
+        }
+        // Mark as visited only after all checks pass and we're actually adding to batch
+        // This ensures tasks can be added if they pass checks from any path
+        visitedInBatch.add(task.id);
+        const batch = (batches[rootExecutorName] =
+            batches[rootExecutorName] ??
+                {
+                    tasks: {},
+                    dependencies: {},
+                    continuousDependencies: {},
+                    roots: [],
+                });
+        batch.tasks[task.id] = task;
+        batch.dependencies[task.id] =
+            this.notScheduledTaskGraph.dependencies[task.id];
+        batch.continuousDependencies[task.id] =
+            this.notScheduledTaskGraph.continuousDependencies[task.id];
+        if (isRoot) {
+            batch.roots.push(task.id);
+        }
+        for (const dep of this.reverseTaskDeps[task.id]) {
+            const depTask = this.taskGraph.tasks[dep];
+            await this.processTaskForBatches(batches, depTask, rootExecutorName, false, visitedInBatch);
+        }
+    }
+    canBatchTaskBeScheduled(task, batchTaskGraph) {
+        // task self needs to have parallelism true
+        // all deps have either completed or belong to the same batch
+        return (task.parallelism === true &&
+            this.taskGraph.dependencies[task.id].every((id) => this.completedTasks.has(id) || !!batchTaskGraph?.tasks[id]));
+    }
+    canBeScheduled(taskId) {
+        const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
+        const hasContinuousDependenciesStarted = this.taskGraph.continuousDependencies[taskId].every((id) => this.runningTasks.has(id));
+        // if dependencies have not completed, cannot schedule
+        if (!hasDependenciesCompleted || !hasContinuousDependenciesStarted) {
+            return false;
+        }
+        // if there are no running tasks, can schedule anything
+        if (this.runningTasks.size === 0) {
+            return true;
+        }
+        const runningTasksNotSupportParallelism = Array.from(this.runningTasks).some((taskId) => {
+            return this.taskGraph.tasks[taskId].parallelism === false;
+        });
+        if (runningTasksNotSupportParallelism) {
+            // if any running tasks do not support parallelism, no other tasks can be scheduled
+            return false;
+        }
+        else {
+            // if all running tasks support parallelism, can only schedule task with parallelism
+            return this.taskGraph.tasks[taskId].parallelism === true;
+        }
+    }
+    getEstimatedTaskTimings() {
+        return this.estimatedTaskTimings;
+    }
+}
+exports.TasksSchedule = TasksSchedule;

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

@@ -0,0 +1,51 @@
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
+export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
+    projects: string[];
+};
+export declare function getDependencyConfigs({ project, target }: {
+    project: string;
+    target: string;
+}, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, projectGraph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[] | undefined;
+export declare function normalizeDependencyConfigDefinition(definition: string | TargetDependencyConfig, currentProject: string, graph: ProjectGraph, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function normalizeDependencyConfigProjects(dependencyConfig: TargetDependencyConfig, currentProject: string, graph: ProjectGraph): NormalizedTargetDependencyConfig;
+export declare function expandDependencyConfigSyntaxSugar(dependencyConfigString: string | TargetDependencyConfig, graph: ProjectGraph): TargetDependencyConfig;
+export declare function expandWildcardTargetConfiguration(dependencyConfig: NormalizedTargetDependencyConfig, allTargetNames: string[]): NormalizedTargetDependencyConfig[];
+export declare function readProjectAndTargetFromTargetString(targetString: string, projects: Record<string, ProjectGraphProjectNode>): {
+    projects?: string[];
+    target: string;
+};
+export declare function getOutputs(p: Record<string, ProjectGraphProjectNode>, target: Task['target'], overrides: Task['overrides']): string[];
+export declare function normalizeTargetDependencyWithStringProjects(dependencyConfig: TargetDependencyConfig): Omit<TargetDependencyConfig, 'projects'> & {
+    projects: string[];
+};
+export declare function validateOutputs(outputs: string[]): void;
+export declare function transformLegacyOutputs(projectRoot: string, outputs: string[]): string[];
+/**
+ * @deprecated Pass the target and overrides instead. This will be removed in v20.
+ */
+export declare function getOutputsForTargetAndConfiguration(task: Task, node: ProjectGraphProjectNode): string[];
+export declare function getOutputsForTargetAndConfiguration(target: Task['target'] | Task, overrides: Task['overrides'] | ProjectGraphProjectNode, node: ProjectGraphProjectNode): string[];
+export declare function interpolate(template: string, data: any): string;
+export declare function getTargetConfigurationForTask(task: Task, projectGraph: ProjectGraph): TargetConfiguration | undefined;
+export declare function getExecutorNameForTask(task: Task, projectGraph: ProjectGraph): string;
+export declare function getExecutorForTask(task: Task, projectGraph: ProjectGraph): ExecutorConfig & {
+    isNgCompat: boolean;
+    isNxExecutor: boolean;
+};
+export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
+export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
+export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
+export declare function getCliPath(): string;
+export declare function getPrintableCommandArgsForTask(task: Task): string[];
+export declare function getSerializedArgsForTask(task: Task, isVerbose: boolean): string[];
+export declare function shouldStreamOutput(task: Task, initiatingProject: string | null): boolean;
+export declare function isCacheableTask(task: Task, options: {
+    cacheableOperations?: string[] | null;
+    cacheableTargets?: string[] | null;
+}): boolean;
+export declare function unparse(options: Object): string[];
+export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;
+//# sourceMappingURL=utils.d.ts.map

package/src/tasks-runner/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/tasks-runner/utils.ts"],"names":[],"mappings":"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"}