@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patternsWeIgnoreInCommunityReport = exports.packagesWeCareAbout = void 0;
+exports.reportHandler = reportHandler;
+exports.getReportData = getReportData;
+exports.findMisalignedPackagesForPackage = findMisalignedPackagesForPackage;
+exports.findInstalledPowerpackPlugins = findInstalledPowerpackPlugins;
+exports.findInstalledCommunityPlugins = findInstalledCommunityPlugins;
+exports.findRegisteredPluginsBeingUsed = findRegisteredPluginsBeingUsed;
+exports.findInstalledPackagesWeCareAbout = findInstalledPackagesWeCareAbout;
+const chalk = require("chalk");
+const output_1 = require("../../utils/output");
+const path_1 = require("path");
+const package_manager_1 = require("../../utils/package-manager");
+const fileutils_1 = require("../../utils/fileutils");
+const package_json_1 = require("../../utils/package-json");
+const local_plugins_1 = require("../../utils/plugins/local-plugins");
+const project_graph_1 = require("../../project-graph/project-graph");
+const semver_1 = require("semver");
+const installed_plugins_1 = require("../../utils/plugins/installed-plugins");
+const installation_directory_1 = require("../../utils/installation-directory");
+const nx_json_1 = require("../../config/nx-json");
+const error_types_1 = require("../../project-graph/error-types");
+const powerpack_1 = require("../../utils/powerpack");
+const nxPackageJson = (0, fileutils_1.readJsonFile)((0, path_1.join)(__dirname, '../../../package.json'));
+exports.packagesWeCareAbout = [
+    'lerna',
+    ...nxPackageJson['nx-migrations'].packageGroup.map((x) => typeof x === 'string' ? x : x.package),
+    '@nrwl/schematics', // manually added since we don't publish it anymore.
+    'typescript',
+];
+exports.patternsWeIgnoreInCommunityReport = [
+    ...exports.packagesWeCareAbout,
+    new RegExp('@nx/powerpack*'),
+    '@schematics/angular',
+    new RegExp('@angular/*'),
+    '@nestjs/schematics',
+];
+const LINE_SEPARATOR = '---------------------------------------';
+/**
+ * Reports relevant version numbers for adding to an Nx issue report
+ *
+ * @remarks
+ *
+ * Must be run within an Nx workspace
+ *
+ */
+async function reportHandler() {
+    const { pm, pmVersion, powerpackLicense, powerpackError, localPlugins, powerpackPlugins, communityPlugins, registeredPlugins, packageVersionsWeCareAbout, outOfSyncPackageGroup, projectGraphError, nativeTarget, } = await getReportData();
+    const fields = [
+        ['Node', process.versions.node],
+        ['OS', `${process.platform}-${process.arch}`],
+        ['Native Target', nativeTarget ?? 'Unavailable'],
+        [pm, pmVersion],
+    ];
+    let padding = Math.max(...fields.map((f) => f[0].length));
+    const bodyLines = fields.map(([field, value]) => `${field.padEnd(padding)}  : ${value}`);
+    bodyLines.push('');
+    padding =
+        Math.max(...packageVersionsWeCareAbout.map((x) => x.package.length)) + 1;
+    packageVersionsWeCareAbout.forEach((p) => {
+        bodyLines.push(`${chalk.green(p.package.padEnd(padding))} : ${chalk.bold(p.version)}`);
+    });
+    if (powerpackLicense) {
+        bodyLines.push('');
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push(chalk.green('Nx Powerpack'));
+        bodyLines.push(`Licensed to ${powerpackLicense.organizationName} for ${powerpackLicense.seatCount} user${powerpackLicense.seatCount > 1 ? 's' : ''} in ${powerpackLicense.workspaceCount} workspace${powerpackLicense.workspaceCount > 1 ? 's' : ''} until ${new Date(powerpackLicense.expiresAt * 1000).toLocaleDateString()}`);
+        bodyLines.push('');
+        padding =
+            Math.max(...powerpackPlugins.map((powerpackPlugin) => powerpackPlugin.name.length)) + 1;
+        for (const powerpackPlugin of powerpackPlugins) {
+            bodyLines.push(`${chalk.green(powerpackPlugin.name.padEnd(padding))} : ${chalk.bold(powerpackPlugin.version)}`);
+        }
+        bodyLines.push('');
+    }
+    else if (powerpackError) {
+        bodyLines.push('');
+        bodyLines.push(chalk.red('Nx Powerpack'));
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push(powerpackError.message);
+        bodyLines.push('');
+    }
+    if (registeredPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('Registered Plugins:');
+        for (const plugin of registeredPlugins) {
+            bodyLines.push(`${chalk.green(plugin)}`);
+        }
+    }
+    if (communityPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        padding = Math.max(...communityPlugins.map((x) => x.name.length)) + 1;
+        bodyLines.push('Community plugins:');
+        communityPlugins.forEach((p) => {
+            bodyLines.push(`${chalk.green(p.name.padEnd(padding))}: ${chalk.bold(p.version)}`);
+        });
+    }
+    if (localPlugins.length) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('Local workspace plugins:');
+        for (const plugin of localPlugins) {
+            bodyLines.push(`\t ${chalk.green(plugin)}`);
+        }
+    }
+    if (outOfSyncPackageGroup) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push(`The following packages should match the installed version of ${outOfSyncPackageGroup.basePackage}`);
+        for (const pkg of outOfSyncPackageGroup.misalignedPackages) {
+            bodyLines.push(`  - ${pkg.name}@${pkg.version}`);
+        }
+        bodyLines.push('');
+        bodyLines.push(`To fix this, run \`nx migrate ${outOfSyncPackageGroup.migrateTarget}\``);
+    }
+    if (projectGraphError) {
+        bodyLines.push(LINE_SEPARATOR);
+        bodyLines.push('⚠️ Unable to construct project graph.');
+        bodyLines.push(projectGraphError.message);
+        bodyLines.push(projectGraphError.stack);
+    }
+    output_1.output.log({
+        title: 'Report complete - copy this into the issue template',
+        bodyLines,
+    });
+}
+async function getReportData() {
+    const pm = (0, package_manager_1.detectPackageManager)();
+    const pmVersion = (0, package_manager_1.getPackageManagerVersion)(pm);
+    const { graph, error: projectGraphError } = await tryGetProjectGraph();
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const localPlugins = await findLocalPlugins(graph, nxJson);
+    const powerpackPlugins = findInstalledPowerpackPlugins();
+    const communityPlugins = findInstalledCommunityPlugins();
+    const registeredPlugins = findRegisteredPluginsBeingUsed(nxJson);
+    const packageVersionsWeCareAbout = findInstalledPackagesWeCareAbout();
+    packageVersionsWeCareAbout.unshift({
+        package: 'nx',
+        version: nxPackageJson.version,
+    });
+    if (globalThis.GLOBAL_NX_VERSION) {
+        packageVersionsWeCareAbout.unshift({
+            package: 'nx (global)',
+            version: globalThis.GLOBAL_NX_VERSION,
+        });
+    }
+    const outOfSyncPackageGroup = findMisalignedPackagesForPackage(nxPackageJson);
+    const native = isNativeAvailable();
+    let powerpackLicense = null;
+    let powerpackError = null;
+    try {
+        powerpackLicense = await (0, powerpack_1.getPowerpackLicenseInformation)();
+    }
+    catch (e) {
+        if (!(e instanceof powerpack_1.NxPowerpackNotInstalledError)) {
+            powerpackError = e;
+        }
+    }
+    return {
+        pm,
+        powerpackLicense,
+        powerpackError,
+        powerpackPlugins,
+        pmVersion,
+        localPlugins,
+        communityPlugins,
+        registeredPlugins,
+        packageVersionsWeCareAbout,
+        outOfSyncPackageGroup,
+        projectGraphError,
+        nativeTarget: native ? native.getBinaryTarget() : null,
+    };
+}
+async function tryGetProjectGraph() {
+    try {
+        return { graph: await (0, project_graph_1.createProjectGraphAsync)() };
+    }
+    catch (error) {
+        if (error instanceof error_types_1.ProjectGraphError) {
+            return {
+                graph: error.getPartialProjectGraph(),
+                error: error,
+            };
+        }
+        return {
+            error,
+        };
+    }
+}
+async function findLocalPlugins(projectGraph, nxJson) {
+    try {
+        const localPlugins = await (0, local_plugins_1.getLocalWorkspacePlugins)((0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson);
+        return Array.from(localPlugins.keys());
+    }
+    catch {
+        return [];
+    }
+}
+function readPackageJson(p) {
+    try {
+        return (0, package_json_1.readModulePackageJson)(p, (0, installation_directory_1.getNxRequirePaths)()).packageJson;
+    }
+    catch {
+        return null;
+    }
+}
+function readPackageVersion(p) {
+    return readPackageJson(p)?.version;
+}
+function findMisalignedPackagesForPackage(base) {
+    const misalignedPackages = [];
+    let migrateTarget = base.version;
+    const { packageGroup } = (0, package_json_1.readNxMigrateConfig)(base);
+    for (const entry of packageGroup ?? []) {
+        const { package: packageName, version } = entry;
+        // should be aligned
+        if (version === '*') {
+            const installedVersion = readPackageVersion(packageName);
+            if (installedVersion && installedVersion !== base.version) {
+                if ((0, semver_1.valid)(installedVersion) && (0, semver_1.gt)(installedVersion, migrateTarget)) {
+                    migrateTarget = installedVersion;
+                }
+                misalignedPackages.push({
+                    name: packageName,
+                    version: installedVersion,
+                });
+            }
+        }
+    }
+    return misalignedPackages.length
+        ? {
+            basePackage: base.name,
+            misalignedPackages,
+            migrateTarget: `${base.name}@${migrateTarget}`,
+        }
+        : undefined;
+}
+function findInstalledPowerpackPlugins() {
+    const installedPlugins = (0, installed_plugins_1.findInstalledPlugins)();
+    return installedPlugins.filter((dep) => new RegExp('@nx/powerpack*').test(dep.name));
+}
+function findInstalledCommunityPlugins() {
+    const installedPlugins = (0, installed_plugins_1.findInstalledPlugins)();
+    return installedPlugins.filter((dep) => dep.name !== 'nx' &&
+        !exports.patternsWeIgnoreInCommunityReport.some((pattern) => typeof pattern === 'string'
+            ? pattern === dep.name
+            : pattern.test(dep.name)));
+}
+function findRegisteredPluginsBeingUsed(nxJson) {
+    if (!nxJson.plugins) {
+        return [];
+    }
+    return nxJson.plugins.map((plugin) => typeof plugin === 'object' ? plugin.plugin : plugin);
+}
+function findInstalledPackagesWeCareAbout() {
+    const packagesWeMayCareAbout = {};
+    // TODO (v20): Remove workaround for hiding @nrwl packages when matching @nx package is found.
+    const packageChangeMap = {
+        '@nrwl/nx-plugin': '@nx/plugin',
+        '@nx/plugin': '@nrwl/nx-plugin',
+        '@nrwl/eslint-plugin-nx': '@nx/eslint-plugin',
+        '@nx/eslint-plugin': '@nrwl/eslint-plugin-nx',
+        '@nrwl/nx-cloud': 'nx-cloud',
+    };
+    for (const pkg of exports.packagesWeCareAbout) {
+        const v = readPackageVersion(pkg);
+        if (v) {
+            // If its a @nrwl scoped package, keep the version if there is no
+            // corresponding @nx scoped package, or it has a different version.
+            if (pkg.startsWith('@nrwl/')) {
+                const otherPackage = packageChangeMap[pkg] ?? pkg.replace('@nrwl/', '@nx/');
+                const otherVersion = packagesWeMayCareAbout[otherPackage];
+                if (!otherVersion || v !== otherVersion) {
+                    packagesWeMayCareAbout[pkg] = v;
+                }
+                // If its a @nx scoped package, always keep the version, and
+                // remove the corresponding @nrwl scoped package if it exists.
+            }
+            else if (pkg.startsWith('@nx/')) {
+                const otherPackage = packageChangeMap[pkg] ?? pkg.replace('@nx/', '@nrwl/');
+                const otherVersion = packagesWeMayCareAbout[otherPackage];
+                if (otherVersion && v === otherVersion) {
+                    delete packagesWeMayCareAbout[otherPackage];
+                }
+                packagesWeMayCareAbout[pkg] = v;
+            }
+            else {
+                packagesWeMayCareAbout[pkg] = v;
+            }
+        }
+    }
+    return Object.entries(packagesWeMayCareAbout).map(([pkg, version]) => ({
+        package: pkg,
+        version,
+    }));
+}
+function isNativeAvailable() {
+    try {
+        return require('../../native');
+    }
+    catch {
+        return false;
+    }
+}

package/src/command-line/reset/command-object.d.ts

@@ -0,0 +1,8 @@
+import { CommandModule } from 'yargs';
+export type ResetCommandOptions = {
+    onlyCache?: boolean;
+    onlyDaemon?: boolean;
+    onlyWorkspaceData?: boolean;
+    onlyCloud?: boolean;
+};
+export declare const yargsResetCommand: CommandModule<Record<string, unknown>, ResetCommandOptions>;

package/src/command-line/reset/command-object.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsResetCommand = void 0;
+exports.yargsResetCommand = {
+    command: 'reset',
+    describe: 'Clears cached Nx artifacts and metadata about the workspace and shuts down the Nx Daemon.',
+    aliases: ['clear-cache'],
+    builder: (yargs) => yargs
+        .option('onlyCache', {
+        description: 'Clears the Nx cache directory. This will remove all local cache entries for tasks, but will not affect the remote cache.',
+        type: 'boolean',
+    })
+        .option('onlyDaemon', {
+        description: 'Stops the Nx Daemon, it will be restarted fresh when the next Nx command is run.',
+        type: 'boolean',
+    })
+        .option('onlyCloud', {
+        description: 'Resets the Nx Cloud client. NOTE: Does not clear the remote cache.',
+        type: 'boolean',
+    })
+        .option('onlyWorkspaceData', {
+        description: 'Clears the workspace data directory. Used by Nx to store cached data about the current workspace (e.g. partial results, incremental data, etc).',
+        type: 'boolean',
+    }),
+    handler: async (argv) => (await Promise.resolve().then(() => require('./reset'))).resetHandler(argv),
+};

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

@@ -0,0 +1,2 @@
+import { ResetCommandOptions } from './command-object';
+export declare function resetHandler(args: ResetCommandOptions): Promise<void>;

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetHandler = resetHandler;
+const node_fs_1 = require("node:fs");
+const client_1 = require("../../daemon/client/client");
+const cache_directory_1 = require("../../utils/cache-directory");
+const output_1 = require("../../utils/output");
+const native_file_cache_location_1 = require("../../native/native-file-cache-location");
+const client_2 = require("../../nx-cloud/utilities/client");
+const get_cloud_options_1 = require("../../nx-cloud/utilities/get-cloud-options");
+// Wait at max 5 seconds before giving up on a failing operation.
+const INCREMENTAL_BACKOFF_MAX_DURATION = 5000;
+// If an operation fails, wait 100ms before first retry.
+const INCREMENTAL_BACKOFF_FIRST_DELAY = 100;
+async function resetHandler(args) {
+    let errors = [];
+    const all = args.onlyDaemon === undefined &&
+        args.onlyCache === undefined &&
+        args.onlyWorkspaceData === undefined;
+    const startupMessage = all
+        ? 'Resetting the Nx cache and stopping the daemon.'
+        : 'Resetting:';
+    const bodyLines = [];
+    if (!all) {
+        if (args.onlyDaemon) {
+            bodyLines.push('- Nx Daemon');
+        }
+        if (args.onlyCache) {
+            bodyLines.push('- Cache directory');
+        }
+        if (args.onlyWorkspaceData) {
+            bodyLines.push('- Workspace data directory');
+        }
+    }
+    output_1.output.note({ title: startupMessage, bodyLines });
+    if (all || args.onlyDaemon) {
+        try {
+            await killDaemon();
+        }
+        catch (e) {
+            errors.push('Failed to stop the Nx Daemon.', e.toString());
+        }
+    }
+    if (all || args.onlyCache) {
+        try {
+            await cleanupCacheEntries();
+        }
+        catch (e) {
+            errors.push('Failed to clean up the cache directory.', e.toString());
+        }
+    }
+    if (all || args.onlyWorkspaceData) {
+        try {
+            await cleanupNativeFileCache();
+        }
+        catch {
+            // ignore, deleting the native file cache is not critical and can fail if another process is locking the file
+        }
+        try {
+            await cleanupWorkspaceData();
+        }
+        catch (e) {
+            errors.push('Failed to clean up the workspace data directory.', e.toString());
+        }
+    }
+    if (all || args.onlyCloud) {
+        try {
+            await resetCloudClient();
+        }
+        catch (e) {
+            errors.push('Failed to reset the Nx Cloud client.', e.toString());
+        }
+    }
+    if (errors.length > 0) {
+        output_1.output.error({
+            title: 'Failed to reset the Nx workspace.',
+            bodyLines: errors,
+        });
+        process.exit(1);
+    }
+    else {
+        output_1.output.success({
+            title: 'Successfully reset the Nx workspace.',
+        });
+    }
+}
+async function killDaemon() {
+    if (client_1.daemonClient.enabled()) {
+        return client_1.daemonClient.stop();
+    }
+}
+async function resetCloudClient() {
+    // Remove nx cloud marker files. This helps if the use happens to run `nx-cloud start-ci-run` or
+    // similar commands on their local machine.
+    try {
+        (await (0, client_2.getCloudClient)((0, get_cloud_options_1.getCloudOptions)())).invoke('cleanup');
+    }
+    catch { }
+}
+function cleanupCacheEntries() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        (0, node_fs_1.rmSync)(cache_directory_1.cacheDir, { recursive: true, force: true });
+    });
+}
+function cleanupNativeFileCache() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        (0, node_fs_1.rmSync)((0, native_file_cache_location_1.getNativeFileCacheLocation)(), { recursive: true, force: true });
+    });
+}
+function cleanupWorkspaceData() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        (0, node_fs_1.rmSync)(cache_directory_1.workspaceDataDirectory, { recursive: true, force: true });
+    });
+}
+async function incrementalBackoff(ms, maxDuration, callback) {
+    try {
+        callback();
+    }
+    catch (e) {
+        if (ms < maxDuration) {
+            await sleep(ms);
+            await incrementalBackoff(ms * 2, maxDuration, callback);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,6 @@
+import { CommandModule } from 'yargs';
+export declare const yargsRunCommand: CommandModule;
+/**
+ * Handles the infix notation for running a target.
+ */
+export declare const yargsNxInfixCommand: CommandModule;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsNxInfixCommand = exports.yargsRunCommand = void 0;
+const yargs_1 = require("yargs");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+exports.yargsRunCommand = {
+    command: 'run [project][:target][:configuration] [_..]',
+    describe: `Run a target for a project
+    (e.g., nx run myapp:serve:production).
+
+    You can also use the infix notation to run a target:
+    (e.g., nx serve myapp --configuration=production)
+
+    You can skip the use of Nx cache by using the --skip-nx-cache option.`,
+    builder: (yargs) => (0, shared_options_1.withRunOneOptions)((0, shared_options_1.withBatch)(yargs)),
+    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-one')).then((m) => m.runOne(process.cwd(), (0, shared_options_1.withOverrides)(args)));
+        });
+        process.exit(exitCode);
+    },
+};
+/**
+ * Handles the infix notation for running a target.
+ */
+exports.yargsNxInfixCommand = {
+    ...exports.yargsRunCommand,
+    command: '$0 <target> [project] [_..]',
+    describe: 'Run a target for a project.',
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            // Yargs parses <target> as 'undefined' if running just 'nx'
+            if (!args.target || args.target === 'undefined') {
+                (0, yargs_1.showHelp)();
+                process.exit(1);
+            }
+            return (await Promise.resolve().then(() => require('./run-one'))).runOne(process.cwd(), (0, shared_options_1.withOverrides)(args, 0));
+        });
+        process.exit(exitCode);
+    },
+};

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

@@ -0,0 +1,7 @@
+import { ExecutorConfig } from '../../config/misc-interfaces';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function normalizeExecutorSchema(schema: Partial<ExecutorConfig['schema']>): ExecutorConfig['schema'];
+export declare function getExecutorInformation(nodeModule: string, executor: string, root: string, projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
+    isNgCompat: boolean;
+    isNxExecutor: boolean;
+};

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExecutorSchema = normalizeExecutorSchema;
+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',
+        properties: !schema.properties || typeof schema.properties !== 'object'
+            ? {}
+            : schema.properties,
+        ...schema,
+    };
+}
+function cacheKey(nodeModule, executor, root) {
+    return `${root}:${nodeModule}:${executor}`;
+}
+const cachedExecutorInformation = {};
+function getExecutorInformation(nodeModule, executor, root, 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);
+        const schema = normalizeExecutorSchema((0, fileutils_1.readJsonFile)(schemaPath));
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir);
+        const batchImplementationFactory = executorConfig.batchImplementation
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir)
+            : null;
+        const hasherFactory = executorConfig.hasher
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir)
+            : 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,7 @@
+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>;