Add a task runner option to run executors without forking

[forivall]

Similar to runInBand for jest, it's useful to be able to run executors in a single process rather than forking out to multiple processes. I used to do this with a custom task runner, but now that custom tasks runners are being deprecated, I wont be able to use that solution going forward. This could be hidden behind an environment variable to avoid people using it accidentally, similar to NX_RUN_COMMANDS_DIRECTLY.

My custom simple-runner

I wanted to publish this on npm, but never got around to it.

import {
  createProjectGraphAsync,
  logger,
  output,
  runExecutor,
  workspaceRoot,
} from '@nx/devkit';
import type {
  ProjectGraph,
  ExecutorContext,
  defaultTasksRunner,
  DefaultTasksRunnerOptions,
  Task,
  TaskGraph,
} from '@nx/devkit';
import { readNxJsonFromDisk } from 'nx/src/devkit-internals';

type LifeCycle = DefaultTasksRunnerOptions['lifeCycle'];
type TaskStatus = Parameters<
  NonNullable<LifeCycle['printTaskTerminalOutput']>
>[1];

type TasksRunnerContextBase = NonNullable<
  Parameters<typeof defaultTasksRunner>[2]
>;
interface TasksRunnerContext extends TasksRunnerContextBase {
  taskGraph: NonNullable<TasksRunnerContextBase['taskGraph']>;
}

type TasksRunner<T> = (
  tasks: Task[],
  options: T,
  context: TasksRunnerContext,
) => Promise<{ [id: string]: TaskStatus }>;

export interface SimpleTasksRunnerOptions {
  lifeCycle: Required<LifeCycle>;
}

export async function exhaustAsyncIterator<T>(
  output: AsyncIterator<T>,
  event: Partial<IteratorResult<T>> = { done: false },
) {
  while (!event.done) {
    event = await output.next();
  }
}

type SimpleTasksRunner = TasksRunner<SimpleTasksRunnerOptions>;
export const simpleTasksRunner: SimpleTasksRunner = async (
  tasks,
  options,
  context,
) => {
  options.lifeCycle.startCommand();
  try {
    return await runAllTasks(tasks, options, context);
  } finally {
    options.lifeCycle.endCommand();
  }
};

function updateTaskGraph(old: TaskGraph, completed: string[]): TaskGraph {
  const tasks = { ...old.tasks };
  for (const taskId of completed) {
    delete tasks[taskId];
  }
  const taskIds = Object.keys(tasks);
  const dependencies = Object.fromEntries(
    taskIds.map((taskId) => [
      taskId,
      old.dependencies[taskId].filter(
        (depTaskId) => !completed.includes(depTaskId),
      ),
    ]),
  );
  const roots = taskIds.filter((taskId) => 0 === dependencies[taskId].length);
  return { dependencies, roots, tasks };
}

const runAllTasks: SimpleTasksRunner = async (tasks, options, context) => {
  const projectGraph: ProjectGraph = await createProjectGraphAsync();

  const projectEntries = Object.entries(projectGraph.nodes).map(
    ([project, { data }]) => [project, data] as const,
  );
  const projectsConfigurations = {
    version: 2,
    projects: Object.fromEntries(projectEntries),
  };
  const nxJsonConfiguration = readNxJsonFromDisk();

  const executorContext: ExecutorContext = {
    nxJsonConfiguration,
    projectGraph,
    projectsConfigurations,
    cwd: process.cwd(),
    isVerbose: 'true' === process.env.NX_VERBOSE_LOGGING,
    root: workspaceRoot,
  };

  const results = Object.fromEntries(
    tasks.map(({ id }): [string, TaskStatus] => [id, 'skipped']),
  );

  const todo = new Set<string>(tasks.map(({ id }) => id));
  const continuedTasks: Array<Promise<void>> = [];
  let todoTaskGraph = context.taskGraph;
  let prevSize = todo.size + 1;
  while (0 < todo.size && prevSize > todo.size) {
    prevSize = todo.size;
    const completed: string[] = [];
    for (const rootTaskId of todoTaskGraph.roots) {
      const task = todoTaskGraph.tasks[rootTaskId];
      options.lifeCycle.startTasks([task], { groupId: 0 });
      options.lifeCycle.scheduleTask(task);
      let status: TaskStatus = 'failure';
      output.logCommand(task.id);
      output.addNewline();
      try {
        const output = await runExecutor(
          task.target,
          task.overrides,
          executorContext,
        );
        const event = await output.next();
        const { success } = event.value as { success: boolean };
        status = success ? 'success' : 'failure';
        if (!event.done) {
          continuedTasks.push(exhaustAsyncIterator(output, event));
        }
        completed.push(task.id);
      } catch (err) {
        logger.error((err && (err.stack || err.message)) || 'Unknown Error!');
      }
      const code = 'success' === status ? 0 : 1;
      options.lifeCycle.endTasks([{ code, status, task }], { groupId: 0 });
      results[task.id] = status;
      todo.delete(task.id);
    }
    todoTaskGraph = updateTaskGraph(todoTaskGraph, completed);
  }
  await Promise.all(continuedTasks);
  return results;
};

export default simpleTasksRunner;

POC change to make it happen: 20.1.x...forivall:nx:forivall/run-executor-directly