@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const batch_messages_1 = require("./batch-messages");
+const workspace_root_1 = require("../../utils/workspace-root");
+const params_1 = require("../../utils/params");
+const project_graph_1 = require("../../project-graph/project-graph");
+const configuration_1 = require("../../config/configuration");
+const async_iterator_1 = require("../../utils/async-iterator");
+const executor_utils_1 = require("../../command-line/run/executor-utils");
+function getBatchExecutor(executorName, projects) {
+    const [nodeModule, exportName] = executorName.split(':');
+    return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);
+}
+async function runTasks(executorName, batchTaskGraph, fullTaskGraph) {
+    const input = {};
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    const nxJsonConfiguration = (0, configuration_1.readNxJson)();
+    const batchExecutor = getBatchExecutor(executorName, projectsConfigurations.projects);
+    const tasks = Object.values(batchTaskGraph.tasks);
+    const context = {
+        root: workspace_root_1.workspaceRoot,
+        cwd: process.cwd(),
+        projectsConfigurations,
+        nxJsonConfiguration,
+        workspace: { ...projectsConfigurations, ...nxJsonConfiguration },
+        isVerbose: false,
+        projectGraph,
+        taskGraph: fullTaskGraph,
+    };
+    for (const task of tasks) {
+        const projectConfiguration = projectsConfigurations.projects[task.target.project];
+        const targetConfiguration = projectConfiguration.targets[task.target.target];
+        input[task.id] = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration, targetConfiguration, batchExecutor.schema, null, process.cwd());
+    }
+    try {
+        const results = await batchExecutor.batchImplementationFactory()(batchTaskGraph, input, tasks[0].overrides, context);
+        if (typeof results !== 'object') {
+            throw new Error(`"${executorName} returned invalid results: ${results}`);
+        }
+        if ((0, async_iterator_1.isAsyncIterator)(results)) {
+            const batchResults = {};
+            do {
+                const current = await results.next();
+                if (!current.done) {
+                    batchResults[current.value.task] = current.value.result;
+                    process.send({
+                        type: batch_messages_1.BatchMessageType.CompleteTask,
+                        task: current.value.task,
+                        result: current.value.result,
+                    });
+                }
+                else {
+                    break;
+                }
+            } while (true);
+            return batchResults;
+        }
+        return results;
+    }
+    catch (e) {
+        const isVerbose = tasks[0].overrides.verbose;
+        console.error(isVerbose ? e : e.message);
+        process.exit(1);
+    }
+}
+process.on('message', async (message) => {
+    switch (message.type) {
+        case batch_messages_1.BatchMessageType.RunTasks: {
+            const results = await runTasks(message.executorName, message.batchTaskGraph, message.fullTaskGraph);
+            process.send({
+                type: batch_messages_1.BatchMessageType.CompleteBatchExecution,
+                results,
+            });
+        }
+    }
+});

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

@@ -0,0 +1,36 @@
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { Task } from '../config/task-graph';
+export type CachedResult = {
+    terminalOutput: string;
+    outputsPath: string;
+    code: number;
+    remote: boolean;
+};
+export type TaskWithCachedResult = {
+    task: Task;
+    cachedResult: CachedResult;
+};
+export declare class Cache {
+    private readonly options;
+    root: string;
+    cachePath: string;
+    terminalOutputsDir: string;
+    private _currentMachineId;
+    constructor(options: DefaultTasksRunnerOptions);
+    removeOldCacheRecords(): void;
+    currentMachineId(): Promise<string>;
+    get(task: Task): Promise<CachedResult | null>;
+    put(task: Task, terminalOutput: string | null, outputs: string[], code: number): Promise<void>;
+    copyFilesFromCache(hash: string, cachedResult: CachedResult, outputs: string[]): Promise<void>;
+    temporaryOutputPath(task: Task): string;
+    private expandOutputsInWorkspace;
+    private expandOutputsInCache;
+    private _expandOutputs;
+    private copy;
+    private remove;
+    private getFromLocalDir;
+    private assertLocalCacheValidity;
+    private createCacheDir;
+    private createTerminalOutputsDir;
+    private tryAndRetry;
+}

package/src/tasks-runner/cache.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cache = void 0;
+const workspace_root_1 = require("../utils/workspace-root");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
+const child_process_1 = require("child_process");
+const cache_directory_1 = require("../utils/cache-directory");
+const node_machine_id_1 = require("node-machine-id");
+class Cache {
+    constructor(options) {
+        this.options = options;
+        this.root = workspace_root_1.workspaceRoot;
+        this.cachePath = this.createCacheDir();
+        this.terminalOutputsDir = this.createTerminalOutputsDir();
+        this._currentMachineId = null;
+    }
+    removeOldCacheRecords() {
+        /**
+         * Even though spawning a process is fast, we don't want to do it every time
+         * the user runs a command. Instead, we want to do it once in a while.
+         */
+        const shouldSpawnProcess = Math.floor(Math.random() * 50) === 1;
+        if (shouldSpawnProcess) {
+            const scriptPath = require.resolve('./remove-old-cache-records.js');
+            try {
+                const p = (0, child_process_1.spawn)('node', [scriptPath, `"${this.cachePath}"`], {
+                    stdio: 'ignore',
+                    detached: true,
+                    shell: false,
+                });
+                p.unref();
+            }
+            catch (e) {
+                console.log(`Unable to start remove-old-cache-records script:`);
+                console.log(e.message);
+            }
+        }
+    }
+    async currentMachineId() {
+        if (!this._currentMachineId) {
+            try {
+                this._currentMachineId = await (0, node_machine_id_1.machineId)();
+            }
+            catch (e) {
+                if (process.env.NX_VERBOSE_LOGGING == 'true') {
+                    console.log(`Unable to get machineId. Error: ${e.message}`);
+                }
+                this._currentMachineId = '';
+            }
+        }
+        return this._currentMachineId;
+    }
+    async get(task) {
+        const res = await this.getFromLocalDir(task);
+        if (res) {
+            await this.assertLocalCacheValidity(task);
+            return { ...res, remote: false };
+        }
+        else if (this.options.remoteCache) {
+            // didn't find it locally but we have a remote cache
+            // attempt remote cache
+            await this.options.remoteCache.retrieve(task.hash, this.cachePath);
+            // try again from local cache
+            const res2 = await this.getFromLocalDir(task);
+            return res2 ? { ...res2, remote: true } : null;
+        }
+        else {
+            return null;
+        }
+    }
+    async put(task, terminalOutput, outputs, code) {
+        return this.tryAndRetry(async () => {
+            const td = (0, path_1.join)(this.cachePath, task.hash);
+            const tdCommit = (0, path_1.join)(this.cachePath, `${task.hash}.commit`);
+            // might be left overs from partially-completed cache invocations
+            await this.remove(tdCommit);
+            await this.remove(td);
+            await (0, fs_extra_1.mkdir)(td);
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'terminalOutput'), terminalOutput ?? 'no terminal output');
+            await (0, fs_extra_1.mkdir)((0, path_1.join)(td, 'outputs'));
+            const expandedOutputs = await this.expandOutputsInWorkspace(outputs);
+            await Promise.all(expandedOutputs.map(async (f) => {
+                const src = (0, path_1.join)(this.root, f);
+                if (await (0, fs_extra_1.pathExists)(src)) {
+                    const cached = (0, path_1.join)(td, 'outputs', f);
+                    await this.copy(src, cached);
+                }
+            }));
+            // we need this file to account for partial writes to the cache folder.
+            // creating this file is atomic, whereas creating a folder is not.
+            // so if the process gets terminated while we are copying stuff into cache,
+            // the cache entry won't be used.
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'code'), code.toString());
+            await (0, fs_extra_1.writeFile)((0, path_1.join)(td, 'source'), await this.currentMachineId());
+            await (0, fs_extra_1.writeFile)(tdCommit, 'true');
+            if (this.options.remoteCache) {
+                await this.options.remoteCache.store(task.hash, this.cachePath);
+            }
+            if (terminalOutput) {
+                const outputPath = this.temporaryOutputPath(task);
+                await (0, fs_extra_1.writeFile)(outputPath, terminalOutput);
+            }
+        });
+    }
+    async copyFilesFromCache(hash, cachedResult, outputs) {
+        return this.tryAndRetry(async () => {
+            const expandedOutputs = await this.expandOutputsInCache(outputs, cachedResult);
+            await Promise.all(expandedOutputs.map(async (f) => {
+                const cached = (0, path_1.join)(cachedResult.outputsPath, f);
+                if (await (0, fs_extra_1.pathExists)(cached)) {
+                    const src = (0, path_1.join)(this.root, f);
+                    await this.remove(src);
+                    await this.copy(cached, src);
+                }
+            }));
+        });
+    }
+    temporaryOutputPath(task) {
+        return (0, path_1.join)(this.terminalOutputsDir, task.hash);
+    }
+    async expandOutputsInWorkspace(outputs) {
+        return this._expandOutputs(outputs, workspace_root_1.workspaceRoot);
+    }
+    async expandOutputsInCache(outputs, cachedResult) {
+        return this._expandOutputs(outputs, cachedResult.outputsPath);
+    }
+    async _expandOutputs(outputs, cwd) {
+        const { expandOutputs } = require('../native');
+        perf_hooks_1.performance.mark('expandOutputs:start');
+        const results = expandOutputs(cwd, outputs);
+        perf_hooks_1.performance.mark('expandOutputs:end');
+        perf_hooks_1.performance.measure('expandOutputs', 'expandOutputs:start', 'expandOutputs:end');
+        return results;
+    }
+    async copy(src, destination) {
+        const { copy } = require('../native');
+        // 'cp -a /path/dir/ dest/' operates differently to 'cp -a /path/dir dest/'
+        // --> which means actual build works but subsequent populate from cache (using cp -a) does not
+        // --> the fix is to remove trailing slashes to ensure consistent & expected behaviour
+        src = src.replace(/[\/\\]$/, '');
+        return new Promise((res, rej) => {
+            try {
+                copy(src, destination);
+                res();
+            }
+            catch (e) {
+                rej(e);
+            }
+        });
+    }
+    async remove(path) {
+        const { remove } = require('../native');
+        return new Promise((res, rej) => {
+            try {
+                remove(path);
+                res();
+            }
+            catch (e) {
+                rej(e);
+            }
+        });
+    }
+    async getFromLocalDir(task) {
+        const tdCommit = (0, path_1.join)(this.cachePath, `${task.hash}.commit`);
+        const td = (0, path_1.join)(this.cachePath, task.hash);
+        if (await (0, fs_extra_1.pathExists)(tdCommit)) {
+            const terminalOutput = await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'terminalOutput'), 'utf-8');
+            let code = 0;
+            try {
+                code = Number(await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'code'), 'utf-8'));
+            }
+            catch { }
+            return {
+                terminalOutput,
+                outputsPath: (0, path_1.join)(td, 'outputs'),
+                code,
+            };
+        }
+        else {
+            return null;
+        }
+    }
+    async assertLocalCacheValidity(task) {
+        const td = (0, path_1.join)(this.cachePath, task.hash);
+        let sourceMachineId = null;
+        try {
+            sourceMachineId = await (0, fs_extra_1.readFile)((0, path_1.join)(td, 'source'), 'utf-8');
+        }
+        catch { }
+        if (sourceMachineId && sourceMachineId != (await this.currentMachineId())) {
+            if (process.env.NX_REJECT_UNKNOWN_LOCAL_CACHE != '0' &&
+                process.env.NX_REJECT_UNKNOWN_LOCAL_CACHE != 'false') {
+                const error = [
+                    `Invalid Cache Directory for Task "${task.id}"`,
+                    `The local cache artifact in "${td}" was not generated on this machine.`,
+                    `As a result, the cache's content integrity cannot be confirmed, which may make cache restoration potentially unsafe.`,
+                    `If your machine ID has changed since the artifact was cached, run "nx reset" to fix this issue.`,
+                    `Read about the error and how to address it here: https://nx.dev/recipes/troubleshooting/unknown-local-cache`,
+                    ``,
+                ].join('\n');
+                throw new Error(error);
+            }
+        }
+    }
+    createCacheDir() {
+        (0, fs_extra_1.mkdirSync)(cache_directory_1.cacheDir, { recursive: true });
+        return cache_directory_1.cacheDir;
+    }
+    createTerminalOutputsDir() {
+        const path = (0, path_1.join)(this.cachePath, 'terminalOutputs');
+        (0, fs_extra_1.mkdirSync)(path, { recursive: true });
+        return path;
+    }
+    tryAndRetry(fn) {
+        let attempts = 0;
+        const baseTimeout = 100;
+        const _try = async () => {
+            try {
+                attempts++;
+                return await fn();
+            }
+            catch (e) {
+                if (attempts === 10) {
+                    // After enough attempts, throw the error
+                    throw e;
+                }
+                await new Promise((res) => setTimeout(res, baseTimeout * attempts));
+                return await _try();
+            }
+        };
+        return _try();
+    }
+}
+exports.Cache = Cache;

package/src/tasks-runner/create-task-graph.d.ts

@@ -0,0 +1,25 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TargetDefaults, TargetDependencies } from '../config/nx-json';
+export declare class ProcessTasks {
+    private readonly defaultDependencyConfigs;
+    private readonly projectGraph;
+    private readonly seen;
+    readonly tasks: {
+        [id: string]: Task;
+    };
+    readonly dependencies: {
+        [k: string]: string[];
+    };
+    constructor(defaultDependencyConfigs: TargetDependencies, projectGraph: ProjectGraph);
+    processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Object, excludeTaskDependencies: boolean): string[];
+    processTask(task: Task, projectUsedToDeriveDependencies: string, configuration: string, overrides: Object): void;
+    private processTasksForMatchingProjects;
+    private processTasksForSingleProject;
+    private processTasksForDependencies;
+    createTask(id: string, project: ProjectGraphProjectNode, target: string, resolvedConfiguration: string | undefined, overrides: Object): Task;
+    resolveConfiguration(project: ProjectGraphProjectNode, target: string, configuration: string | undefined): string;
+    getId(project: string, target: string, configuration: string | undefined): string;
+}
+export declare function createTaskGraph(projectGraph: ProjectGraph, defaultDependencyConfigs: TargetDependencies, projectNames: string[], targets: string[], configuration: string | undefined, overrides: Object, excludeTaskDependencies?: boolean): TaskGraph;
+export declare function mapTargetDefaultsToDependencies(defaults: TargetDefaults | undefined): TargetDependencies;

package/src/tasks-runner/create-task-graph.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapTargetDefaultsToDependencies = exports.createTaskGraph = exports.ProcessTasks = void 0;
+const utils_1 = require("./utils");
+const project_graph_utils_1 = require("../utils/project-graph-utils");
+const find_matching_projects_1 = require("../utils/find-matching-projects");
+const output_1 = require("../utils/output");
+class ProcessTasks {
+    constructor(defaultDependencyConfigs, projectGraph) {
+        this.defaultDependencyConfigs = defaultDependencyConfigs;
+        this.projectGraph = projectGraph;
+        this.seen = new Set();
+        this.tasks = {};
+        this.dependencies = {};
+    }
+    processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies) {
+        for (const projectName of projectNames) {
+            for (const target of targets) {
+                const project = this.projectGraph.nodes[projectName];
+                if (targets.length === 1 || project.data.targets[target]) {
+                    const resolvedConfiguration = this.resolveConfiguration(project, target, configuration);
+                    const id = this.getId(projectName, target, resolvedConfiguration);
+                    const task = this.createTask(id, project, target, resolvedConfiguration, overrides);
+                    this.tasks[task.id] = task;
+                    this.dependencies[task.id] = [];
+                }
+            }
+        }
+        // used when excluding tasks
+        const initialTasks = { ...this.tasks };
+        for (const taskId of Object.keys(this.tasks)) {
+            const task = this.tasks[taskId];
+            this.processTask(task, task.target.project, configuration, overrides);
+        }
+        if (excludeTaskDependencies) {
+            for (let t of Object.keys(this.tasks)) {
+                if (!initialTasks[t]) {
+                    delete this.tasks[t];
+                    delete this.dependencies[t];
+                }
+            }
+            for (let d of Object.keys(this.dependencies)) {
+                this.dependencies[d] = this.dependencies[d].filter((dd) => !!initialTasks[dd]);
+            }
+        }
+        for (const projectName of Object.keys(this.dependencies)) {
+            if (this.dependencies[projectName].length > 1) {
+                this.dependencies[projectName] = [
+                    ...new Set(this.dependencies[projectName]).values(),
+                ];
+            }
+        }
+        return Object.keys(this.dependencies).filter((d) => this.dependencies[d].length === 0);
+    }
+    processTask(task, projectUsedToDeriveDependencies, configuration, overrides) {
+        const seenKey = `${task.id}-${projectUsedToDeriveDependencies}`;
+        if (this.seen.has(seenKey)) {
+            return;
+        }
+        this.seen.add(seenKey);
+        const dependencyConfigs = (0, utils_1.getDependencyConfigs)({ project: task.target.project, target: task.target.target }, this.defaultDependencyConfigs, this.projectGraph);
+        for (const dependencyConfig of dependencyConfigs) {
+            const taskOverrides = dependencyConfig.params === 'forward'
+                ? overrides
+                : { __overrides_unparsed__: [] };
+            if (dependencyConfig.projects) {
+                this.processTasksForMatchingProjects(dependencyConfig, projectUsedToDeriveDependencies, configuration, task, taskOverrides, overrides);
+            }
+            else if (dependencyConfig.dependencies) {
+                this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
+            }
+            else {
+                this.processTasksForSingleProject(task, task.target.project, dependencyConfig, configuration, taskOverrides, overrides);
+            }
+        }
+    }
+    processTasksForMatchingProjects(dependencyConfig, projectUsedToDeriveDependencies, configuration, task, taskOverrides, overrides) {
+        const targetProjectSpecifiers = typeof dependencyConfig.projects === 'string'
+            ? [dependencyConfig.projects]
+            : dependencyConfig.projects;
+        for (const projectSpecifier of targetProjectSpecifiers) {
+            // Lerna uses `dependencies` in `prepNxOptions`, so we need to maintain
+            // support for it until lerna can be updated to use the syntax.
+            // TODO(@agentender): Remove this part in v17
+            if (projectSpecifier === 'dependencies' &&
+                !this.projectGraph.nodes[projectSpecifier]) {
+                this.processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides);
+            }
+            else {
+                // Since we need to maintain support for dependencies, it is more coherent
+                // that we also support self.
+                // TODO(@agentender): Remove this part in v17
+                const matchingProjects = 
+                /** LERNA SUPPORT START - Remove in v17 */
+                projectSpecifier === 'self' &&
+                    !this.projectGraph.nodes[projectSpecifier]
+                    ? [task.target.project]
+                    : /** LERNA SUPPORT END */
+                        (0, find_matching_projects_1.findMatchingProjects)([projectSpecifier], this.projectGraph.nodes);
+                if (matchingProjects.length === 0) {
+                    output_1.output.warn({
+                        title: `\`dependsOn\` is misconfigured for ${task.target.project}:${task.target.target}`,
+                        bodyLines: [
+                            `Project pattern "${projectSpecifier}" does not match any projects.`,
+                        ],
+                    });
+                }
+                for (const projectName of matchingProjects) {
+                    this.processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides);
+                }
+            }
+        }
+    }
+    processTasksForSingleProject(task, projectName, dependencyConfig, configuration, taskOverrides, overrides) {
+        const selfProject = this.projectGraph.nodes[projectName];
+        if ((0, project_graph_utils_1.projectHasTarget)(selfProject, dependencyConfig.target)) {
+            const resolvedConfiguration = this.resolveConfiguration(selfProject, dependencyConfig.target, configuration);
+            const selfTaskId = this.getId(selfProject.name, dependencyConfig.target, resolvedConfiguration);
+            if (task.id !== selfTaskId) {
+                this.dependencies[task.id].push(selfTaskId);
+            }
+            if (!this.tasks[selfTaskId]) {
+                const newTask = this.createTask(selfTaskId, selfProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
+                this.tasks[selfTaskId] = newTask;
+                this.dependencies[selfTaskId] = [];
+                this.processTask(newTask, newTask.target.project, configuration, overrides);
+            }
+        }
+    }
+    processTasksForDependencies(projectUsedToDeriveDependencies, dependencyConfig, configuration, task, taskOverrides, overrides) {
+        for (const dep of this.projectGraph.dependencies[projectUsedToDeriveDependencies]) {
+            const depProject = this.projectGraph.nodes[dep.target];
+            // this is to handle external dependencies
+            if (!depProject)
+                continue;
+            if ((0, project_graph_utils_1.projectHasTarget)(depProject, dependencyConfig.target)) {
+                const resolvedConfiguration = this.resolveConfiguration(depProject, dependencyConfig.target, configuration);
+                const depTargetId = this.getId(depProject.name, dependencyConfig.target, resolvedConfiguration);
+                if (task.id !== depTargetId) {
+                    this.dependencies[task.id].push(depTargetId);
+                }
+                if (!this.tasks[depTargetId]) {
+                    const newTask = this.createTask(depTargetId, depProject, dependencyConfig.target, resolvedConfiguration, taskOverrides);
+                    this.tasks[depTargetId] = newTask;
+                    this.dependencies[depTargetId] = [];
+                    this.processTask(newTask, newTask.target.project, configuration, overrides);
+                }
+            }
+            else {
+                this.processTask(task, depProject.name, configuration, overrides);
+            }
+        }
+    }
+    createTask(id, project, target, resolvedConfiguration, overrides) {
+        if (!project.data.targets[target]) {
+            throw new Error(`Cannot find configuration for task ${project.name}:${target}`);
+        }
+        if (!project.data.targets[target].executor) {
+            throw new Error(`Target "${project.name}:${target}" does not have an executor configured`);
+        }
+        const qualifiedTarget = {
+            project: project.name,
+            target,
+            configuration: resolvedConfiguration,
+        };
+        const interpolatedOverrides = interpolateOverrides(overrides, project.name, project.data);
+        return {
+            id,
+            target: qualifiedTarget,
+            projectRoot: project.data.root,
+            overrides: interpolatedOverrides,
+            outputs: (0, utils_1.getOutputs)(this.projectGraph.nodes, qualifiedTarget, interpolatedOverrides),
+            // TODO(v19): Remove cast here after typing is moved back onto TargetConfiguration
+            cache: project.data.targets[target].cache,
+        };
+    }
+    resolveConfiguration(project, target, configuration) {
+        const defaultConfiguration = project.data.targets?.[target]?.defaultConfiguration;
+        configuration ??= defaultConfiguration;
+        return (0, project_graph_utils_1.projectHasTargetAndConfiguration)(project, target, configuration)
+            ? configuration
+            : defaultConfiguration;
+    }
+    getId(project, target, configuration) {
+        let id = `${project}:${target}`;
+        if (configuration) {
+            id += `:${configuration}`;
+        }
+        return id;
+    }
+}
+exports.ProcessTasks = ProcessTasks;
+function createTaskGraph(projectGraph, defaultDependencyConfigs, projectNames, targets, configuration, overrides, excludeTaskDependencies = false) {
+    const p = new ProcessTasks(defaultDependencyConfigs, projectGraph);
+    const roots = p.processTasks(projectNames, targets, configuration, overrides, excludeTaskDependencies);
+    return {
+        roots,
+        tasks: p.tasks,
+        dependencies: p.dependencies,
+    };
+}
+exports.createTaskGraph = createTaskGraph;
+function mapTargetDefaultsToDependencies(defaults) {
+    const res = {};
+    Object.keys(defaults ?? {}).forEach((k) => {
+        res[k] = defaults[k].dependsOn;
+    });
+    return res;
+}
+exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
+function interpolateOverrides(args, projectName, project) {
+    const interpolatedArgs = { ...args };
+    Object.entries(interpolatedArgs).forEach(([name, value]) => {
+        interpolatedArgs[name] =
+            typeof value === 'string'
+                ? (0, utils_1.interpolate)(value, {
+                    workspaceRoot: '',
+                    projectRoot: project.root,
+                    projectName: project.name,
+                    project: { ...project, name: projectName }, // this is legacy
+                })
+                : value;
+    });
+    return interpolatedArgs;
+}

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

@@ -0,0 +1,20 @@
+import { TasksRunner } from './tasks-runner';
+import { LifeCycle } from './life-cycle';
+export interface RemoteCache {
+    retrieve: (hash: string, cacheDirectory: string) => Promise<boolean>;
+    store: (hash: string, cacheDirectory: string) => Promise<boolean>;
+}
+export interface DefaultTasksRunnerOptions {
+    parallel?: number;
+    cacheableOperations?: string[];
+    cacheableTargets?: string[];
+    runtimeCacheInputs?: string[];
+    cacheDirectory?: string;
+    remoteCache?: RemoteCache;
+    lifeCycle: LifeCycle;
+    captureStderr?: boolean;
+    skipNxCache?: boolean;
+    batch?: boolean;
+}
+export declare const defaultTasksRunner: TasksRunner<DefaultTasksRunnerOptions>;
+export default defaultTasksRunner;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTasksRunner = void 0;
+const task_orchestrator_1 = require("./task-orchestrator");
+const defaultTasksRunner = async (tasks, options, context) => {
+    if (options['parallel'] === 'false' ||
+        options['parallel'] === false) {
+        options['parallel'] = 1;
+    }
+    else if (options['parallel'] === 'true' ||
+        options['parallel'] === true ||
+        options['parallel'] === undefined ||
+        options['parallel'] === '') {
+        options['parallel'] = Number(options['maxParallel'] || 3);
+    }
+    options.lifeCycle.startCommand();
+    try {
+        return await runAllTasks(tasks, options, context);
+    }
+    finally {
+        options.lifeCycle.endCommand();
+    }
+};
+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);
+    return orchestrator.run();
+}
+exports.default = exports.defaultTasksRunner;

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

@@ -0,0 +1 @@
+export {};

package/src/tasks-runner/fork.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const psuedo_ipc_1 = require("./psuedo-ipc");
+const psuedoIPCPath = process.argv[2];
+const forkId = process.argv[3];
+const script = (0, path_1.join)(__dirname, '../../bin/run-executor.js');
+const childProcess = (0, child_process_1.fork)(script, {
+    stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+});
+const psuedoIPC = new psuedo_ipc_1.PsuedoIPCClient(psuedoIPCPath);
+psuedoIPC.onMessageFromParent(forkId, (message) => {
+    childProcess.send(message);
+});
+psuedoIPC.notifyChildIsReady(forkId);
+process.on('message', (message) => {
+    psuedoIPC.sendMessageToParent(message);
+});
+childProcess.on('exit', (code) => {
+    psuedoIPC.close();
+    process.exit(code);
+});