Executors & Task Management

/**
 * Run an executor for a specific target
 * @param targetDescription - Target to execute
 * @param options - Options to pass to the executor
 * @param context - Execution context
 * @returns Async iterator of execution results
 */
function runExecutor<T = any>(
  targetDescription: Target,
  options: T,
  context: ExecutorContext
): Promise<AsyncIterableIterator<{ success: boolean; [key: string]: any }>>;

/**
 * Parse a target string into components
 * @param targetString - String in format "project:target:configuration"
 * @param projectGraph - Project graph for validation
 * @param cwd - Current working directory
 * @returns Parsed target object
 */
function parseTargetString(
  targetString: string,
  projectGraph?: ProjectGraph,
  cwd?: string
): Target;

/**
 * Convert target object back to string format
 * @param target - Target object to serialize
 * @returns Target string in format "project:target:configuration"
 */
function targetToTargetString(target: Target): string;

/**
 * Read options for a specific target
 * @param target - Target configuration
 * @param context - Executor context
 * @returns Resolved target options
 */
function readTargetOptions<T = any>(
  target: TargetConfiguration,
  context: ExecutorContext
): T;

import { 
  ExecutorContext, 
  runExecutor, 
  parseTargetString,
  targetToTargetString 
} from "@nrwl/devkit";

async function executeTarget(context: ExecutorContext) {
  // Parse a target string
  const target = parseTargetString('my-app:build:production');
  console.log(target);
  // Output: { project: 'my-app', target: 'build', configuration: 'production' }
  
  // Convert back to string
  const targetString = targetToTargetString(target);
  console.log(targetString); // "my-app:build:production"
  
  // Run an executor
  const results = await runExecutor(target, {}, context);
  
  for await (const result of results) {
    if (result.success) {
      console.log('Target executed successfully');
    } else {
      console.error('Target execution failed');
    }
  }
}

/**
 * Executor function signature
 * @template T - Options type for the executor
 */
type Executor<T = any> = (
  options: T,
  context: ExecutorContext
) => Promise<{ success: boolean; [key: string]: any }> | AsyncIterableIterator<{ success: boolean; [key: string]: any }>;

/**
 * Async iterator executor for long-running processes
 */
type AsyncIteratorExecutor<T = any> = (
  options: T,
  context: ExecutorContext
) => AsyncIterableIterator<{ success: boolean; [key: string]: any }>;

/**
 * Promise-based executor for simple operations
 */
type PromiseExecutor<T = any> = (
  options: T,
  context: ExecutorContext
) => Promise<{ success: boolean; [key: string]: any }>;

/**
 * Context provided to executors during execution
 */
interface ExecutorContext {
  /** Workspace root directory */
  root: string;
  /** Current working directory */
  cwd: string;
  /** Workspace configuration */
  workspace: WorkspaceJsonConfiguration;
  /** Whether verbose logging is enabled */
  isVerbose: boolean;
  /** Name of the project being executed */
  projectName?: string;
  /** Name of the target being executed */
  targetName?: string;
  /** Name of the configuration being used */
  configurationName?: string;
  /** Project configuration */
  projectsConfigurations?: ProjectsConfigurations;
  /** Project graph */
  projectGraph?: ProjectGraph;
  /** Task graph */
  taskGraph?: TaskGraph;
  /** Name inputs for the current task */
  hasher?: Hasher;
}

/**
 * Target specification
 */
interface Target {
  /** Project name */
  project: string;
  /** Target name */
  target: string;
  /** Configuration name (optional) */
  configuration?: string;
}

/**
 * Configuration schema for executors.json
 */
interface ExecutorsJson {
  extends?: string;
  executors?: Record<string, ExecutorConfiguration>;
  builders?: Record<string, ExecutorConfiguration>;
}

/**
 * Configuration for a single executor
 */
interface ExecutorConfiguration {
  /** Path to executor implementation */
  implementation: string;
  /** Path to options schema */
  schema: string;
  /** Whether executor is hidden from CLI */
  hasher?: string;
  /** Human-readable description */
  description?: string;
}

import { ExecutorContext, Executor } from "@nrwl/devkit";

interface BuildExecutorOptions {
  outputPath: string;
  main: string;
  tsConfig: string;
  watch?: boolean;
}

const buildExecutor: Executor<BuildExecutorOptions> = async (
  options: BuildExecutorOptions,
  context: ExecutorContext
) => {
  const { root, projectName, targetName } = context;
  
  console.log(`Building ${projectName}:${targetName}`);
  console.log(`Output path: ${options.outputPath}`);
  console.log(`Main file: ${options.main}`);
  
  try {
    // Perform build logic here
    await performBuild(options, context);
    
    return { success: true };
  } catch (error) {
    console.error('Build failed:', error);
    return { success: false, error: error.message };
  }
};

export default buildExecutor;

/**
 * Get output paths for a target and configuration
 * @param target - Target configuration
 * @param configuration - Configuration name
 * @returns Array of output paths
 */
function getOutputsForTargetAndConfiguration(
  target: TargetConfiguration,
  configuration: string | undefined
): string[];

/**
 * Default tasks runner implementation
 * @param tasks - Tasks to execute
 * @param options - Task runner options
 * @param context - Execution context
 * @returns Promise resolving to execution results
 */
function defaultTasksRunner(
  tasks: Task[],
  options: DefaultTasksRunnerOptions,
  context: {
    target: string;
    projectGraph: ProjectGraph;
    nxJson: NxJsonConfiguration;
    hasher: Hasher;
  }
): Promise<{ [id: string]: TaskStatus }>;

/**
 * Task graph representation
 */
interface TaskGraph {
  roots: string[];
  tasks: Record<string, Task>;
  dependencies: Record<string, string[]>;
}

/**
 * Individual task in the graph
 */
interface Task {
  id: string;
  target: {
    project: string;
    target: string;
    configuration?: string;
  };
  outputs: string[];
  inputs: Record<string, string>;
  overrides: any;
  projectRoot: string;
}

/**
 * Task execution status
 */
type TaskStatus = 'success' | 'failure' | 'skipped' | 'local-cache' | 'remote-cache';

/**
 * Options for the default tasks runner
 */
interface DefaultTasksRunnerOptions {
  parallel?: number;
  maxParallel?: number;
  cacheableOperations?: string[];
  runtimeCacheInputs?: string[];
  cacheDirectory?: string;
  remoteCache?: RemoteCache;
  captureStderr?: boolean;
  skipNxCache?: boolean;
  batch?: boolean;
}

/**
 * Remote cache configuration
 */
interface RemoteCache {
  url: string;
  timeout?: number;
}

import { 
  Task,
  TaskGraph,
  defaultTasksRunner,
  getOutputsForTargetAndConfiguration 
} from "@nrwl/devkit";

function manageTaskExecution() {
  // Get outputs for a target
  const buildTarget: TargetConfiguration = {
    executor: '@nx/js:tsc',
    options: {
      outputPath: 'dist/libs/my-lib'
    }
  };
  
  const outputs = getOutputsForTargetAndConfiguration(buildTarget, 'production');
  console.log('Build outputs:', outputs);
  
  // Create a task
  const buildTask: Task = {
    id: 'my-lib:build',
    target: {
      project: 'my-lib',
      target: 'build'
    },
    outputs: ['dist/libs/my-lib'],
    inputs: {},
    overrides: {},
    projectRoot: 'libs/my-lib'
  };
}

/**
 * Convert Nx executor to Angular builder format
 * @param executor - Nx executor function
 * @returns Angular builder function
 */
function convertNxExecutor<T = any>(executor: Executor<T>): any;

import { convertNxExecutor, Executor } from "@nrwl/devkit";

const myExecutor: Executor = async (options, context) => {
  // Executor implementation
  return { success: true };
};

// Convert for use with Angular CLI
export const builder = convertNxExecutor(myExecutor);