@depup/nx 22.5.4-depup.0

package/src/command-line/run/executor-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/run/executor-utils.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,cAAc,EAGf,MAAM,8BAA8B,CAAC;AAOtC,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAEhF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,GACxC,cAAc,CAAC,QAAQ,CAAC,CAa1B;AAMD,wBAAgB,aAAa,CAC3B,cAAc,EAAE,MAAM,GACrB,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,CAEhC;AAID,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM;AACZ;;GAEG;AACH,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,GAC7C,cAAc,GAAG;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CA6DjE"}

package/src/command-line/run/executor-utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExecutorSchema = normalizeExecutorSchema;
+exports.parseExecutor = parseExecutor;
+exports.getExecutorInformation = getExecutorInformation;
+const path_1 = require("path");
+const plugins_1 = require("../../project-graph/plugins");
+const fileutils_1 = require("../../utils/fileutils");
+const schema_utils_1 = require("../../config/schema-utils");
+const installation_directory_1 = require("../../utils/installation-directory");
+function normalizeExecutorSchema(schema) {
+    const version = (schema.version ??= 1);
+    return {
+        version,
+        outputCapture: (schema.outputCapture ?? version < 2) ? 'direct-nodejs' : 'pipe',
+        continuous: schema.continuous ?? false,
+        properties: !schema.properties || typeof schema.properties !== 'object'
+            ? {}
+            : schema.properties,
+        ...schema,
+    };
+}
+function cacheKey(nodeModule, executor, root) {
+    return `${root}:${nodeModule}:${executor}`;
+}
+function parseExecutor(executorString) {
+    return executorString.split(':');
+}
+const cachedExecutorInformation = {};
+function getExecutorInformation(nodeModule, executor, root, 
+/**
+ * A map of projects keyed by project name
+ */
+projects) {
+    try {
+        const key = cacheKey(nodeModule, executor, root);
+        if (cachedExecutorInformation[key])
+            return cachedExecutorInformation[key];
+        const { executorsFilePath, executorConfig, isNgCompat } = readExecutorJson(nodeModule, executor, root, projects);
+        const executorsDir = (0, path_1.dirname)(executorsFilePath);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir, nodeModule, projects);
+        const schema = normalizeExecutorSchema((0, fileutils_1.readJsonFile)(schemaPath));
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir, nodeModule, projects);
+        const batchImplementationFactory = executorConfig.batchImplementation
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir, nodeModule, projects)
+            : null;
+        const hasherFactory = executorConfig.hasher
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir, nodeModule, projects)
+            : null;
+        const res = {
+            schema,
+            implementationFactory,
+            batchImplementationFactory,
+            hasherFactory,
+            isNgCompat,
+            isNxExecutor: !isNgCompat,
+        };
+        cachedExecutorInformation[key] = res;
+        return res;
+    }
+    catch (e) {
+        throw new Error(`Unable to resolve ${nodeModule}:${executor}.\n${e.message}`);
+    }
+}
+function readExecutorJson(nodeModule, executor, root, projects, extraRequirePaths = []) {
+    const { json: packageJson, path: packageJsonPath } = (0, plugins_1.readPluginPackageJson)(nodeModule, projects, root
+        ? [
+            root,
+            __dirname,
+            process.cwd(),
+            ...(0, installation_directory_1.getNxRequirePaths)(),
+            ...extraRequirePaths,
+        ]
+        : [__dirname, process.cwd(), ...(0, installation_directory_1.getNxRequirePaths)(), ...extraRequirePaths]);
+    const executorsFile = packageJson.executors ?? packageJson.builders;
+    if (!executorsFile) {
+        throw new Error(`The "${nodeModule}" package does not support Nx executors.`);
+    }
+    const basePath = (0, path_1.dirname)(packageJsonPath);
+    const executorsFilePath = require.resolve((0, path_1.join)(basePath, executorsFile));
+    const executorsJson = (0, fileutils_1.readJsonFile)(executorsFilePath);
+    const executorConfig = executorsJson.executors?.[executor] || executorsJson.builders?.[executor];
+    if (!executorConfig) {
+        throw new Error(`Cannot find executor '${executor}' in ${executorsFilePath}.`);
+    }
+    if (typeof executorConfig === 'string') {
+        // Angular CLI can have a builder pointing to another package:builder
+        const [packageName, executorName] = executorConfig.split(':');
+        return readExecutorJson(packageName, executorName, root, projects, [
+            basePath,
+        ]);
+    }
+    const isNgCompat = !executorsJson.executors?.[executor];
+    return { executorsFilePath, executorConfig, isNgCompat };
+}

package/src/command-line/run/run-one.d.ts

@@ -0,0 +1,18 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectGraph } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function runOne(cwd: string, args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;
+export declare function parseRunOneOptions(cwd: string, parsedArgs: {
+    [k: string]: any;
+}, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): {
+    project: any;
+    target: any;
+    configuration: any;
+    parsedArgs: any;
+};
+//# sourceMappingURL=run-one.d.ts.map

package/src/command-line/run/run-one.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-one.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/run/run-one.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EACL,YAAY,EAEb,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAiBlF,wBAAsB,MAAM,CAC1B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,uBAAuB,GAAE,MAAM,CAC7B,MAAM,EACN,CAAC,sBAAsB,GAAG,MAAM,CAAC,EAAE,CAC/B,EACN,YAAY,GAGP;IACH,uBAAuB,EAAE,OAAO,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC;CAC1B,GACA,OAAO,CAAC,IAAI,CAAC,CAiEf;AAwDD,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,UAAU,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAChC,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,mBAAmB,GAC1B;IAAE,OAAO,MAAC;IAAC,MAAM,MAAC;IAAC,aAAa,MAAC;IAAC,UAAU,MAAA;CAAE,CA+DhD"}

package/src/command-line/run/run-one.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOne = runOne;
+exports.parseRunOneOptions = parseRunOneOptions;
+const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
+const configuration_1 = require("../../config/configuration");
+const project_graph_1 = require("../../project-graph/project-graph");
+const run_command_1 = require("../../tasks-runner/run-command");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const output_1 = require("../../utils/output");
+const split_target_1 = require("../../utils/split-target");
+const workspace_root_1 = require("../../utils/workspace-root");
+const graph_1 = require("../graph/graph");
+const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
+async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
+    excludeTaskDependencies: args.excludeTaskDependencies,
+    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+}) {
+    performance.mark('code-loading:end');
+    performance.measure('code-loading', 'init-local', 'code-loading:end');
+    const nxJson = (0, configuration_1.readNxJson)();
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const opts = parseRunOneOptions(cwd, args, projectGraph, nxJson);
+    const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
+        ...opts.parsedArgs,
+        configuration: opts.configuration,
+        targets: [opts.target],
+    }, 'run-one', { printWarnings: args.graph !== 'stdout' }, nxJson);
+    const { projects, projectName } = getProjects(projectGraph, opts.project);
+    if (nxArgs.help) {
+        await (await Promise.resolve().then(() => require('./run'))).printTargetRunHelp({
+            ...opts,
+            project: projectName,
+        }, workspace_root_1.workspaceRoot);
+        process.exit(0);
+    }
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    if (nxArgs.graph) {
+        const projectNames = projects.map((t) => t.name);
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+        return await (0, graph_1.generateGraph)({
+            watch: true,
+            open: true,
+            view: 'tasks',
+            targets: nxArgs.targets,
+            projects: projectNames,
+            file,
+        }, projectNames);
+    }
+    else {
+        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
+        process.exit(status);
+    }
+}
+function getProjects(projectGraph, projectName) {
+    if (projectGraph.nodes[projectName]) {
+        return {
+            projectName: projectName,
+            projects: [projectGraph.nodes[projectName]],
+            projectsMap: {
+                [projectName]: projectGraph.nodes[projectName],
+            },
+        };
+    }
+    else {
+        const projects = (0, find_matching_projects_1.findMatchingProjects)([projectName], projectGraph.nodes);
+        if (projects.length === 1) {
+            const projectName = projects[0];
+            const project = projectGraph.nodes[projectName];
+            return {
+                projectName,
+                projects: [project],
+                projectsMap: {
+                    [project.data.name]: project,
+                },
+            };
+        }
+        else if (projects.length > 1) {
+            output_1.output.error({
+                title: `Multiple projects matched:`,
+                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
+            });
+            process.exit(1);
+        }
+    }
+    output_1.output.error({
+        title: `Cannot find project '${projectName}'`,
+    });
+    process.exit(1);
+}
+const targetAliases = {
+    b: 'build',
+    e: 'e2e',
+    l: 'lint',
+    s: 'serve',
+    t: 'test',
+};
+const PROJECT_TARGET_CONFIG = 'project:target:configuration';
+function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
+    const defaultProjectName = (0, calculate_default_project_name_1.calculateDefaultProjectName)(cwd, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson);
+    let project;
+    let target;
+    let configuration;
+    if (parsedArgs[PROJECT_TARGET_CONFIG]?.lastIndexOf(':') > 0) {
+        // run case
+        [project, target, configuration] = (0, split_target_1.splitTarget)(parsedArgs[PROJECT_TARGET_CONFIG], projectGraph);
+        // this is to account for "nx npmscript:dev"
+        if (project && !target && defaultProjectName) {
+            target = project;
+            project = defaultProjectName;
+        }
+    }
+    else if (parsedArgs.target) {
+        target = parsedArgs.target;
+    }
+    else if (parsedArgs[PROJECT_TARGET_CONFIG]) {
+        // If project:target:configuration exists but has no colon, check if it's a project with run target
+        if (projectGraph.nodes[parsedArgs[PROJECT_TARGET_CONFIG]]?.data?.targets?.run) {
+            target = 'run';
+            project = parsedArgs[PROJECT_TARGET_CONFIG];
+        }
+        else {
+            target = parsedArgs[PROJECT_TARGET_CONFIG];
+        }
+    }
+    if (parsedArgs.project) {
+        project = parsedArgs.project;
+    }
+    if (!project && defaultProjectName) {
+        project = defaultProjectName;
+    }
+    if (!project || !target) {
+        throw new Error(`Both project and target have to be specified`);
+    }
+    if (targetAliases[target]) {
+        target = targetAliases[target];
+    }
+    if (parsedArgs.configuration) {
+        configuration = parsedArgs.configuration;
+    }
+    else if (parsedArgs.prod) {
+        configuration = 'production';
+    }
+    const res = { project, target, configuration, parsedArgs };
+    delete parsedArgs['c'];
+    delete parsedArgs[PROJECT_TARGET_CONFIG];
+    delete parsedArgs['configuration'];
+    delete parsedArgs['prod'];
+    delete parsedArgs['project'];
+    return res;
+}

package/src/command-line/run/run.d.ts

@@ -0,0 +1,52 @@
+import { Schema } from '../../utils/params';
+import { ProjectsConfigurations } from '../../config/workspace-json-project-json';
+import { ExecutorContext } from '../../config/misc-interfaces';
+import { TaskGraph } from '../../config/task-graph';
+export interface Target {
+    project: string;
+    target: string;
+    configuration?: string;
+}
+export declare function printRunHelp(opts: {
+    project: string;
+    target: string;
+}, schema: Schema, plugin: {
+    plugin: string;
+    entity: string;
+}): void;
+export declare function validateProject(projects: ProjectsConfigurations, projectName: string): void;
+/**
+ * Loads and invokes executor.
+ *
+ * This is analogous to invoking executor from the terminal, with the exception
+ * that the params aren't parsed from the string, but instead provided parsed already.
+ *
+ * Apart from that, it works the same way:
+ *
+ * - it will load the workspace configuration
+ * - it will resolve the target
+ * - it will load the executor and the schema
+ * - it will load the options for the appropriate configuration
+ * - it will run the validations and will set the default
+ * - and, of course, it will invoke the executor
+ *
+ * Example:
+ *
+ * ```typescript
+ * for await (const s of await runExecutor({project: 'myproj', target: 'serve'}, {watch: true}, context)) {
+ *   // s.success
+ * }
+ * ```
+ *
+ * Note that the return value is a promise of an iterator, so you need to await before iterating over it.
+ */
+export declare function runExecutor<T extends {
+    success: boolean;
+}>(targetDescription: Target, overrides: {
+    [k: string]: any;
+}, context: ExecutorContext): Promise<AsyncIterableIterator<T>>;
+export declare function printTargetRunHelp(targetDescription: Target, root: string): Promise<number>;
+export declare function run(cwd: string, root: string, targetDescription: Target, overrides: {
+    [k: string]: any;
+}, isVerbose: boolean, taskGraph: TaskGraph): Promise<number>;
+//# sourceMappingURL=run.d.ts.map

package/src/command-line/run/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/run/run.ts"],"names":[],"mappings":"AACA,OAAO,EAA6B,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAKvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAClF,OAAO,EAAY,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAmBpD,MAAM,WAAW,MAAM;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EACzC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,QAM3C;AAED,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,sBAAsB,EAChC,WAAW,EAAE,MAAM,QAMpB;AAiLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,WAAW,CAAC,CAAC,SAAS;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAC9D,iBAAiB,EAAE,MAAM,EACzB,SAAS,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC/B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAenC;AAED,wBAAgB,kBAAkB,CAAC,iBAAiB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,mBAYzE;AAED,wBAAgB,GAAG,CACjB,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,SAAS,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC/B,SAAS,EAAE,OAAO,EAClB,SAAS,EAAE,SAAS,mBAoBrB"}

package/src/command-line/run/run.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRunHelp = printRunHelp;
+exports.validateProject = validateProject;
+exports.runExecutor = runExecutor;
+exports.printTargetRunHelp = printTargetRunHelp;
+exports.run = run;
+const npm_run_path_1 = require("npm-run-path");
+const params_1 = require("../../utils/params");
+const handle_errors_1 = require("../../utils/handle-errors");
+const print_help_1 = require("../../utils/print-help");
+const path_1 = require("path");
+const serialize_overrides_into_command_line_1 = require("../../utils/serialize-overrides-into-command-line");
+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("./executor-utils");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+const child_process_1 = require("child_process");
+function printRunHelp(opts, schema, plugin) {
+    (0, print_help_1.printHelp)(`run ${opts.project}:${opts.target}`, schema, {
+        mode: 'run',
+        ...plugin,
+    });
+}
+function validateProject(projects, projectName) {
+    const project = projects.projects[projectName];
+    if (!project) {
+        throw new Error(`Could not find project "${projectName}"`);
+    }
+}
+function isPromise(v) {
+    return typeof v?.then === 'function';
+}
+async function* promiseToIterator(v) {
+    yield await v;
+}
+async function iteratorToProcessStatusCode(i) {
+    const { success } = await (0, async_iterator_1.getLastValueFromAsyncIterableIterator)(i);
+    return success ? 0 : 1;
+}
+async function parseExecutorAndTarget({ project, target }, root, projectsConfigurations) {
+    const proj = projectsConfigurations.projects[project];
+    const targetConfig = proj.targets?.[target];
+    if (!targetConfig) {
+        throw new Error(`Cannot find target '${target}' for project '${project}'`);
+    }
+    const [nodeModule, executor] = (0, executor_utils_1.parseExecutor)(targetConfig.executor);
+    const { schema, implementationFactory } = (0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects);
+    return { executor, implementationFactory, nodeModule, schema, targetConfig };
+}
+async function printTargetRunHelpInternal({ project, target }, root, projectsConfigurations) {
+    const { executor, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target }, root, projectsConfigurations);
+    printRunHelp({ project, target }, schema, {
+        plugin: nodeModule,
+        entity: executor,
+    });
+    if (nodeModule === 'nx' &&
+        executor === 'run-commands' &&
+        targetConfig.options.command) {
+        const command = targetConfig.options.command.split(' ')[0];
+        const helpCommand = `${command} --help`;
+        const localEnv = (0, npm_run_path_1.env)();
+        const env = {
+            ...process.env,
+            ...localEnv,
+        };
+        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+            await new Promise(() => {
+                const cp = terminal.runCommand(helpCommand, { jsEnv: env });
+                cp.onExit((code) => {
+                    process.exit(code);
+                });
+            });
+        }
+        else {
+            const cp = (0, child_process_1.exec)(helpCommand, {
+                env,
+                windowsHide: false,
+            });
+            cp.on('exit', (code) => {
+                process.exit(code);
+            });
+        }
+    }
+    else {
+        process.exit(0);
+    }
+}
+async function runExecutorInternal({ project, target, configuration }, overrides, root, cwd, projectsConfigurations, nxJsonConfiguration, projectGraph, taskGraph, isVerbose) {
+    validateProject(projectsConfigurations, project);
+    const { executor, implementationFactory, nodeModule, schema, targetConfig } = await parseExecutorAndTarget({ project, target, configuration }, root, projectsConfigurations);
+    configuration ??= targetConfig.defaultConfiguration;
+    const combinedOptions = (0, params_1.combineOptionsForExecutor)(overrides, configuration, targetConfig, schema, project, (0, path_1.relative)(root, cwd), isVerbose);
+    if ((0, executor_utils_1.getExecutorInformation)(nodeModule, executor, root, projectsConfigurations.projects).isNxExecutor) {
+        const implementation = implementationFactory();
+        const r = implementation(combinedOptions, {
+            root,
+            target: targetConfig,
+            projectsConfigurations,
+            nxJsonConfiguration,
+            projectName: project,
+            targetName: target,
+            configurationName: configuration,
+            projectGraph,
+            taskGraph,
+            cwd,
+            isVerbose,
+        });
+        if (isPromise(r)) {
+            return promiseToIterator(r);
+        }
+        else if ((0, async_iterator_1.isAsyncIterator)(r)) {
+            return r;
+        }
+        else {
+            throw new TypeError(`NX Executor "${targetConfig.executor}" should return either a Promise or an AsyncIterator`);
+        }
+    }
+    else {
+        require('../../adapter/compat');
+        const observable = await (await Promise.resolve().then(() => require('../../adapter/ngcli-adapter'))).scheduleTarget(root, {
+            project,
+            target,
+            configuration,
+            runOptions: combinedOptions,
+            projects: projectsConfigurations.projects,
+        }, isVerbose);
+        const { eachValueFrom } = await Promise.resolve().then(() => require('../../adapter/rxjs-for-await'));
+        return eachValueFrom(observable);
+    }
+}
+/**
+ * Loads and invokes executor.
+ *
+ * This is analogous to invoking executor from the terminal, with the exception
+ * that the params aren't parsed from the string, but instead provided parsed already.
+ *
+ * Apart from that, it works the same way:
+ *
+ * - it will load the workspace configuration
+ * - it will resolve the target
+ * - it will load the executor and the schema
+ * - it will load the options for the appropriate configuration
+ * - it will run the validations and will set the default
+ * - and, of course, it will invoke the executor
+ *
+ * Example:
+ *
+ * ```typescript
+ * for await (const s of await runExecutor({project: 'myproj', target: 'serve'}, {watch: true}, context)) {
+ *   // s.success
+ * }
+ * ```
+ *
+ * Note that the return value is a promise of an iterator, so you need to await before iterating over it.
+ */
+async function runExecutor(targetDescription, overrides, context) {
+    return await runExecutorInternal(targetDescription, {
+        ...overrides,
+        __overrides_unparsed__: (0, serialize_overrides_into_command_line_1.serializeOverridesIntoCommandLine)(overrides),
+    }, context.root, context.cwd, context.projectsConfigurations, context.nxJsonConfiguration, context.projectGraph, context.taskGraph, context.isVerbose);
+}
+function printTargetRunHelp(targetDescription, root) {
+    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+    return (0, handle_errors_1.handleErrors)(false, async () => {
+        const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        await printTargetRunHelpInternal(targetDescription, root, projectsConfigurations);
+    });
+}
+function run(cwd, root, targetDescription, overrides, isVerbose, taskGraph) {
+    const projectGraph = (0, project_graph_1.readCachedProjectGraph)();
+    return (0, handle_errors_1.handleErrors)(isVerbose, async () => {
+        const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+        return iteratorToProcessStatusCode(await runExecutorInternal(targetDescription, overrides, root, cwd, projectsConfigurations, (0, configuration_1.readNxJson)(), projectGraph, taskGraph, isVerbose));
+    });
+}

package/src/command-line/run-many/command-object.d.ts

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+export declare const yargsRunManyCommand: CommandModule;
+//# sourceMappingURL=command-object.d.ts.map

package/src/command-line/run-many/command-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-object.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/run-many/command-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAYtC,eAAO,MAAM,mBAAmB,EAAE,aAuBjC,CAAC"}

package/src/command-line/run-many/command-object.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsRunManyCommand = void 0;
+const handle_errors_1 = require("../../utils/handle-errors");
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsRunManyCommand = {
+    command: 'run-many',
+    describe: 'Run target for multiple listed projects.',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunManyOptions)((0, shared_options_1.withOutputStyleOption)((0, shared_options_1.withTargetAndConfigurationOption)((0, shared_options_1.withBatch)(yargs))))), 'run-many'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            await Promise.resolve().then(() => require('./run-many')).then((m) => m.runMany((0, shared_options_1.withOverrides)(args)));
+        });
+        process.exit(exitCode);
+    },
+};

package/src/command-line/run-many/run-many.d.ts

@@ -0,0 +1,11 @@
+import { NxArgs } from '../../utils/command-line-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function runMany(args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;
+export declare function projectsToRun(nxArgs: NxArgs, projectGraph: ProjectGraph): ProjectGraphProjectNode[];
+//# sourceMappingURL=run-many.d.ts.map

package/src/command-line/run-many/run-many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-many.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/run-many/run-many.ts"],"names":[],"mappings":"AACA,OAAO,EACL,MAAM,EAGP,MAAM,gCAAgC,CAAC;AAIxC,OAAO,EACL,YAAY,EACZ,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,MAAM,0CAA0C,CAAC;AAMlF,wBAAsB,OAAO,CAC3B,IAAI,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EAC1B,uBAAuB,GAAE,MAAM,CAC7B,MAAM,EACN,CAAC,sBAAsB,GAAG,MAAM,CAAC,EAAE,CAC/B,EACN,YAAY,GAGP;IACH,uBAAuB,EAAE,OAAO,CAAC;IACjC,eAAe,EAAE,OAAO,CAAC;CAC1B,iBAgDF;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,YAAY,GACzB,uBAAuB,EAAE,CA2C3B"}

package/src/command-line/run-many/run-many.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMany = runMany;
+exports.projectsToRun = projectsToRun;
+const run_command_1 = require("../../tasks-runner/run-command");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
+const perf_hooks_1 = require("perf_hooks");
+const project_graph_1 = require("../../project-graph/project-graph");
+const configuration_1 = require("../../config/configuration");
+const output_1 = require("../../utils/output");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const graph_1 = require("../graph/graph");
+async function runMany(args, extraTargetDependencies = {}, extraOptions = {
+    excludeTaskDependencies: args.excludeTaskDependencies,
+    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+}) {
+    perf_hooks_1.performance.mark('code-loading:end');
+    perf_hooks_1.performance.measure('code-loading', 'init-local', 'code-loading:end');
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'run-many', { printWarnings: args.graph !== 'stdout' }, nxJson);
+    if (nxArgs.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projects = projectsToRun(nxArgs, projectGraph);
+    if (nxArgs.graph) {
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+        const projectNames = projects.map((t) => t.name);
+        return await (0, graph_1.generateGraph)({
+            watch: true,
+            open: true,
+            view: 'tasks',
+            all: nxArgs.all && (!nxArgs.projects || nxArgs.projects.length === 0),
+            targets: nxArgs.targets,
+            projects: projectNames,
+            file,
+        }, projectNames);
+    }
+    else {
+        const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+        process.exit(status);
+    }
+}
+function projectsToRun(nxArgs, projectGraph) {
+    const selectedProjects = {};
+    const validProjects = runnableForTarget(projectGraph.nodes, nxArgs.targets);
+    const invalidProjects = [];
+    // --all is default now, if --projects is provided, it'll override the --all
+    if (nxArgs.all && nxArgs.projects.length === 0) {
+        for (const projectName of validProjects) {
+            selectedProjects[projectName] = projectGraph.nodes[projectName];
+        }
+    }
+    else {
+        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.projects, projectGraph.nodes);
+        for (const project of matchingProjects) {
+            if (!validProjects.has(project)) {
+                invalidProjects.push(project);
+            }
+            else {
+                selectedProjects[project] = projectGraph.nodes[project];
+            }
+        }
+        if (invalidProjects.length > 0) {
+            output_1.output.warn({
+                title: `The following projects do not have a configuration for any of the provided targets ("${nxArgs.targets.join(', ')}")`,
+                bodyLines: invalidProjects.map((name) => `- ${name}`),
+            });
+        }
+    }
+    const excludedProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, selectedProjects);
+    for (const excludedProject of excludedProjects) {
+        delete selectedProjects[excludedProject];
+    }
+    return Object.values(selectedProjects);
+}
+function runnableForTarget(projects, targets) {
+    const runnable = new Set();
+    for (let projectName in projects) {
+        const project = projects[projectName];
+        if (targets.find((target) => (0, project_graph_utils_1.projectHasTarget)(project, target))) {
+            runnable.add(projectName);
+        }
+    }
+    return runnable;
+}