@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/release/plan-check.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePlanCheckCLIHandler = void 0;
+exports.createAPI = createAPI;
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const output_1 = require("../../utils/output");
+const handle_errors_1 = require("../../utils/handle-errors");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
+const get_touched_projects_for_group_1 = require("./utils/get-touched-projects-for-group");
+const print_config_1 = require("./utils/print-config");
+const releasePlanCheckCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releasePlanCheckCLIHandler = releasePlanCheckCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    return async function releasePlanCheck(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        // No filtering is applied here, as we want to consider all release groups for plan:check
+        const { error: filterError, releaseGroups } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        // If no release groups have version plans enabled, provide an explicit error
+        if (!releaseGroups.some((group) => group.versionPlans)) {
+            output_1.output.error({
+                title: 'Version plans are not enabled',
+                bodyLines: [
+                    'Please ensure at least one release group has version plans enabled in your Nx release configuration if you want to use this command.',
+                    // TODO: Add docs link here once it is available
+                ],
+            });
+            return 1;
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
+        // Resolve the final values for base, head etc to use when resolving the changes to consider
+        const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+            printWarnings: args.verbose,
+        }, nxJson);
+        const changedFiles = (0, command_line_utils_1.parseFiles)(nxArgs).files;
+        if (nxArgs.verbose) {
+            if (changedFiles.length) {
+                output_1.output.log({
+                    title: `Changed files based on resolved "base" (${nxArgs.base}) and "head" (${nxArgs.head ?? 'HEAD'})`,
+                    bodyLines: changedFiles.map((file) => `  - ${file}`),
+                });
+            }
+            else {
+                output_1.output.warn({
+                    title: 'No changed files found based on resolved "base" and "head"',
+                });
+            }
+        }
+        const resolvedAllFileData = await (0, all_file_data_1.allFileData)();
+        const getTouchedProjectsForGroup = (0, get_touched_projects_for_group_1.createGetTouchedProjectsForGroup)(nxArgs, projectGraph, changedFiles, resolvedAllFileData);
+        const NOTE_ABOUT_VERBOSE_LOGGING = 'Run with --verbose to see the full list of changed files used for the touched projects logic.';
+        let hasErrors = false;
+        for (const releaseGroup of releaseGroups) {
+            // The current release group doesn't leverage version plans
+            if (!releaseGroup.versionPlans) {
+                continue;
+            }
+            const resolvedVersionPlans = releaseGroup.resolvedVersionPlans || [];
+            // Check upfront if the release group as a whole is featured in any version plan files
+            const matchingVersionPlanFiles = resolvedVersionPlans.filter((plan) => 'groupVersionBump' in plan);
+            if (matchingVersionPlanFiles.length) {
+                output_1.output.log({
+                    title: `${releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? `There are`
+                        : `Release group "${releaseGroup.name}" has`} pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...matchingVersionPlanFiles.map((plan) => `  - "${plan.groupVersionBump}" in ${plan.fileName}`),
+                    ],
+                });
+                continue;
+            }
+            const touchedProjectsUnderReleaseGroup = await getTouchedProjectsForGroup(releaseGroup, 
+            // We do not take any --projects or --groups filtering into account for plan:check
+            releaseGroup.projects, false);
+            const projectsInResolvedVersionPlans = resolvedVersionPlans.reduce((acc, plan) => {
+                if ('projectVersionBumps' in plan) {
+                    for (const project in plan.projectVersionBumps) {
+                        acc[project] = acc[project] || [];
+                        acc[project].push({
+                            bump: plan.projectVersionBumps[project],
+                            fileName: plan.fileName,
+                        });
+                    }
+                }
+                return acc;
+            }, {});
+            // Ensure each touched project under this release group features in at least one version plan file
+            let touchedProjectsNotFoundInVersionPlans = [];
+            for (const touchedProject of touchedProjectsUnderReleaseGroup) {
+                if (!resolvedVersionPlans.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+                const matchingVersionPlanFileEntries = projectsInResolvedVersionPlans[touchedProject];
+                if (!matchingVersionPlanFileEntries?.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+            }
+            // Log any resolved pending bumps, regardless of whether the projects were directly touched or not
+            for (const [projectName, entries] of Object.entries(projectsInResolvedVersionPlans)) {
+                output_1.output.log({
+                    title: `Project "${projectName}" has pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...entries.map(({ bump, fileName }) => `  - "${bump}" in ${fileName}`),
+                    ],
+                });
+            }
+            if (touchedProjectsNotFoundInVersionPlans.length) {
+                const bodyLines = [
+                    `The following touched projects${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''} do not feature in any version plan files:`,
+                    ...touchedProjectsNotFoundInVersionPlans.map((project) => `  - ${project}`),
+                    '',
+                    'Please use `nx release plan` to generate missing version plans, or adjust your "versionPlans.ignorePatternsForPlanCheck" config stop certain files from affecting the projects for the purposes of this command.',
+                ];
+                if (!nxArgs.verbose) {
+                    bodyLines.push('', NOTE_ABOUT_VERBOSE_LOGGING);
+                }
+                output_1.output.error({
+                    title: 'Touched projects missing version plans',
+                    bodyLines,
+                });
+                // At least one project in one release group has an issue
+                hasErrors = true;
+            }
+        }
+        // Do not print success message if any projects are missing version plans
+        if (hasErrors) {
+            return 1;
+        }
+        const bodyLines = [];
+        if (!nxArgs.verbose) {
+            bodyLines.push(NOTE_ABOUT_VERBOSE_LOGGING);
+        }
+        output_1.output.success({
+            title: 'All touched projects have, or do not require, version plans.',
+            bodyLines,
+        });
+        return 0;
+    };
+}

package/src/command-line/release/plan.d.ts

@@ -0,0 +1,4 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { PlanOptions } from './command-object';
+export declare const releasePlanCLIHandler: (args: PlanOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: PlanOptions) => Promise<string | number>;

package/src/command-line/release/plan.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePlanCLIHandler = void 0;
+exports.createAPI = createAPI;
+const enquirer_1 = require("enquirer");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const semver_1 = require("semver");
+const tmp_1 = require("tmp");
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const output_1 = require("../../utils/output");
+const handle_errors_1 = require("../../utils/handle-errors");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
+const generate_version_plan_content_1 = require("./utils/generate-version-plan-content");
+const get_touched_projects_for_group_1 = require("./utils/get-touched-projects-for-group");
+const launch_editor_1 = require("./utils/launch-editor");
+const print_changes_1 = require("./utils/print-changes");
+const print_config_1 = require("./utils/print-config");
+const releasePlanCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releasePlanCLIHandler = releasePlanCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    return async function releasePlan(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        // If no release groups have version plans enabled, it doesn't make sense to use the plan command only to set yourself up for an error at release time
+        if (!releaseGroups.some((group) => group.versionPlans === true)) {
+            if (releaseGroups.length === 1) {
+                output_1.output.warn({
+                    title: `Version plans are not enabled in your release configuration`,
+                    bodyLines: [
+                        'To enable version plans, set `"versionPlans": true` at the top level of your `"release"` configuration',
+                    ],
+                });
+                return 0;
+            }
+            output_1.output.warn({
+                title: 'No release groups have version plans enabled',
+                bodyLines: [
+                    'To enable version plans, set `"versionPlans": true` at the top level of your `"release"` configuration to apply it to all groups, otherwise set it at the release group level',
+                ],
+            });
+            return 0;
+        }
+        // Resolve the final values for base, head etc to use when resolving the changes to consider
+        const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+            printWarnings: args.verbose,
+        }, nxJson);
+        const versionPlanBumps = {};
+        const setBumpIfNotNone = (projectOrGroup, version) => {
+            if (version !== 'none') {
+                versionPlanBumps[projectOrGroup] = version;
+            }
+        };
+        // Changed files are only relevant if considering touched projects
+        let changedFiles = [];
+        let getProjectsToVersionForGroup;
+        if (args.onlyTouched) {
+            changedFiles = (0, command_line_utils_1.parseFiles)(nxArgs).files;
+            if (nxArgs.verbose) {
+                if (changedFiles.length) {
+                    output_1.output.log({
+                        title: `Changed files based on resolved "base" (${nxArgs.base}) and "head" (${nxArgs.head ?? 'HEAD'})`,
+                        bodyLines: changedFiles.map((file) => `  - ${file}`),
+                    });
+                }
+                else {
+                    output_1.output.warn({
+                        title: 'No changed files found based on resolved "base" and "head"',
+                    });
+                }
+            }
+            const resolvedAllFileData = await (0, all_file_data_1.allFileData)();
+            getProjectsToVersionForGroup = (0, get_touched_projects_for_group_1.createGetTouchedProjectsForGroup)(nxArgs, projectGraph, changedFiles, resolvedAllFileData);
+        }
+        if (args.projects?.length) {
+            /**
+             * Run plan for all remaining release groups and filtered projects within them
+             */
+            for (const releaseGroup of releaseGroups) {
+                const releaseGroupName = releaseGroup.name;
+                const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+                let applicableProjects = releaseGroupProjectNames;
+                if (args.onlyTouched &&
+                    typeof getProjectsToVersionForGroup === 'function') {
+                    applicableProjects = await getProjectsToVersionForGroup(releaseGroup, releaseGroupProjectNames, true);
+                }
+                if (!applicableProjects.length) {
+                    continue;
+                }
+                if (releaseGroup.projectsRelationship === 'independent') {
+                    for (const project of applicableProjects) {
+                        setBumpIfNotNone(project, args.bump ||
+                            (await promptForVersion(`How do you want to bump the version of the project "${project}"${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                                ? ''
+                                : ` within group "${releaseGroupName}"`}?`)));
+                    }
+                }
+                else {
+                    setBumpIfNotNone(releaseGroupName, args.bump ||
+                        (await promptForVersion(`How do you want to bump the versions of ${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                            ? 'all projects'
+                            : `the projects in the group "${releaseGroupName}"`}?`)));
+                }
+            }
+            // Create a version plan file if applicable
+            await createVersionPlanFileForBumps(args, versionPlanBumps);
+            return 0;
+        }
+        /**
+         * Run plan for all remaining release groups
+         */
+        for (const releaseGroup of releaseGroups) {
+            const releaseGroupName = releaseGroup.name;
+            let applicableProjects = releaseGroup.projects;
+            if (args.onlyTouched &&
+                typeof getProjectsToVersionForGroup === 'function') {
+                applicableProjects = await getProjectsToVersionForGroup(releaseGroup, releaseGroup.projects, false);
+            }
+            if (!applicableProjects.length) {
+                continue;
+            }
+            if (releaseGroup.projectsRelationship === 'independent') {
+                for (const project of applicableProjects) {
+                    setBumpIfNotNone(project, args.bump ||
+                        (await promptForVersion(`How do you want to bump the version of the project "${project}"${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                            ? ''
+                            : ` within group "${releaseGroupName}"`}?`)));
+                }
+            }
+            else {
+                setBumpIfNotNone(releaseGroupName, args.bump ||
+                    (await promptForVersion(`How do you want to bump the versions of ${releaseGroupName === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? 'all projects'
+                        : `the projects in the group "${releaseGroupName}"`}?`)));
+            }
+        }
+        // Create a version plan file if applicable
+        await createVersionPlanFileForBumps(args, versionPlanBumps);
+        return 0;
+    };
+}
+async function createVersionPlanFileForBumps(args, versionPlanBumps) {
+    if (!Object.keys(versionPlanBumps).length) {
+        let bodyLines = [];
+        if (args.onlyTouched) {
+            bodyLines = [
+                'This might be because no projects have been changed, or projects you expected to release have not been touched',
+                'To include all projects, not just those that have been changed, pass --only-touched=false',
+                'Alternatively, you can specify alternate --base and --head refs to include only changes from certain commits',
+            ];
+        }
+        output_1.output.warn({
+            title: 'No version bumps were selected so no version plan file was created.',
+            bodyLines,
+        });
+        return 0;
+    }
+    const versionPlanName = `version-plan-${new Date().getTime()}`;
+    const versionPlanMessage = args.message || (await promptForMessage(versionPlanName));
+    const versionPlanFileContent = (0, generate_version_plan_content_1.generateVersionPlanContent)(versionPlanBumps, versionPlanMessage);
+    const versionPlanFileName = `${versionPlanName}.md`;
+    if (args.dryRun) {
+        output_1.output.logSingleLine(`Would create version plan file "${versionPlanFileName}", but --dry-run was set.`);
+        (0, print_changes_1.printDiff)('', versionPlanFileContent, 1);
+    }
+    else {
+        output_1.output.logSingleLine(`Creating version plan file "${versionPlanFileName}"`);
+        (0, print_changes_1.printDiff)('', versionPlanFileContent, 1);
+        const versionPlansAbsolutePath = (0, version_plans_1.getVersionPlansAbsolutePath)();
+        await (0, promises_1.mkdir)(versionPlansAbsolutePath, { recursive: true });
+        await (0, promises_1.writeFile)((0, node_path_1.join)(versionPlansAbsolutePath, versionPlanFileName), versionPlanFileContent);
+    }
+}
+async function promptForVersion(message) {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'version',
+                message,
+                type: 'select',
+                choices: [...semver_1.RELEASE_TYPES, 'none'],
+            },
+        ]);
+        return reply.version;
+    }
+    catch (e) {
+        output_1.output.log({
+            title: 'Cancelled version plan creation.',
+        });
+        process.exit(0);
+    }
+}
+async function promptForMessage(versionPlanName) {
+    let message;
+    do {
+        message = await _promptForMessage(versionPlanName);
+    } while (!message);
+    return message;
+}
+async function _promptForMessage(versionPlanName) {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'message',
+                message: 'What changelog message would you like associated with this change? (Leave blank to open an external editor for multi-line messages/easier editing)',
+                type: 'input',
+            },
+        ]);
+        let message = reply.message.trim();
+        if (!message.length) {
+            const tmpDir = (0, tmp_1.dirSync)().name;
+            const messageFilePath = (0, node_path_1.join)(tmpDir, `DRAFT_MESSAGE__${versionPlanName}.md`);
+            (0, node_fs_1.writeFileSync)(messageFilePath, '');
+            await (0, launch_editor_1.launchEditor)(messageFilePath);
+            message = (0, node_fs_1.readFileSync)(messageFilePath, 'utf-8');
+        }
+        message = message.trim();
+        if (!message) {
+            output_1.output.warn({
+                title: 'A changelog message is required in order to create the version plan file',
+                bodyLines: [],
+            });
+        }
+        return message;
+    }
+    catch (e) {
+        output_1.output.log({
+            title: 'Cancelled version plan creation.',
+        });
+        process.exit(0);
+    }
+}

package/src/command-line/release/publish.d.ts

@@ -0,0 +1,4 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { PublishOptions } from './command-object';
+export declare const releasePublishCLIHandler: (args: PublishOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: PublishOptions, isCLI?: boolean) => Promise<number>;

package/src/command-line/release/publish.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePublishCLIHandler = void 0;
+exports.createAPI = createAPI;
+const nx_json_1 = require("../../config/nx-json");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+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 output_1 = require("../../utils/output");
+const handle_errors_1 = require("../../utils/handle-errors");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const graph_1 = require("../graph/graph");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const print_config_1 = require("./utils/print-config");
+const releasePublishCLIHandler = (args) => (0, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args, true));
+exports.releasePublishCLIHandler = releasePublishCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    /**
+     * NOTE: This function is also exported for programmatic usage and forms part of the public API
+     * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
+     * to have control over their own error handling when using the API.
+     */
+    return async function releasePublish(args, isCLI = false) {
+        /**
+         * When used via the CLI, the args object will contain a __overrides_unparsed__ property that is
+         * important for invoking the relevant executor behind the scenes.
+         *
+         * We intentionally do not include that in the function signature, however, so as not to cause
+         * confusing errors for programmatic consumers of this function.
+         */
+        const _args = args;
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, _args.projects, _args.groups);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        /**
+         * If the user is filtering to a subset of projects or groups, we should not run the publish task
+         * for dependencies, because that could cause projects outset of the filtered set to be published.
+         */
+        const shouldExcludeTaskDependencies = _args.projects?.length > 0 ||
+            _args.groups?.length > 0 ||
+            args.excludeTaskDependencies;
+        let overallExitStatus = 0;
+        if (args.projects?.length) {
+            /**
+             * Run publishing for all remaining release groups and filtered projects within them
+             */
+            for (const releaseGroup of releaseGroups) {
+                const status = await runPublishOnProjects(_args, projectGraph, nxJson, Array.from(releaseGroupToFilteredProjects.get(releaseGroup)), isCLI, {
+                    excludeTaskDependencies: shouldExcludeTaskDependencies,
+                    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+                });
+                if (status !== 0) {
+                    overallExitStatus = status || 1;
+                }
+            }
+            return overallExitStatus;
+        }
+        /**
+         * Run publishing for all remaining release groups
+         */
+        for (const releaseGroup of releaseGroups) {
+            const status = await runPublishOnProjects(_args, projectGraph, nxJson, releaseGroup.projects, isCLI, {
+                excludeTaskDependencies: shouldExcludeTaskDependencies,
+                loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+            });
+            if (status !== 0) {
+                overallExitStatus = status || 1;
+            }
+        }
+        return overallExitStatus;
+    };
+}
+async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, isCLI, extraOptions) {
+    const projectsToRun = projectNames.map((projectName) => projectGraph.nodes[projectName]);
+    const overrides = (0, command_line_utils_1.createOverrides)(args.__overrides_unparsed__);
+    if (args.registry) {
+        overrides.registry = args.registry;
+    }
+    if (args.tag) {
+        overrides.tag = args.tag;
+    }
+    if (args.otp) {
+        overrides.otp = args.otp;
+    }
+    if (args.access) {
+        overrides.access = args.access;
+    }
+    if (args.dryRun) {
+        overrides.dryRun = args.dryRun;
+        /**
+         * Ensure the env var is set too, so that any and all publish executors triggered
+         * indirectly via dependsOn can also pick up on the fact that this is a dry run.
+         */
+        process.env.NX_DRY_RUN = 'true';
+    }
+    if (args.firstRelease) {
+        overrides.firstRelease = args.firstRelease;
+    }
+    const requiredTargetName = 'nx-release-publish';
+    if (args.graph) {
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(args);
+        const projectNamesWithTarget = projectsToRun
+            .map((t) => t.name)
+            .filter((projectName) => (0, project_graph_utils_1.projectHasTarget)(projectGraph.nodes[projectName], requiredTargetName));
+        await (0, graph_1.generateGraph)({
+            watch: true,
+            all: false,
+            open: true,
+            view: 'tasks',
+            targets: [requiredTargetName],
+            projects: projectNamesWithTarget,
+            file,
+        }, projectNamesWithTarget);
+        return 0;
+    }
+    const projectsWithTarget = projectsToRun.filter((project) => (0, project_graph_utils_1.projectHasTarget)(project, requiredTargetName));
+    if (projectsWithTarget.length === 0) {
+        throw new Error(`Based on your config, the following projects were matched for publishing but do not have the "${requiredTargetName}" target specified:\n${[
+            ...projectsToRun.map((p) => `- ${p.name}`),
+            '',
+            `This is usually caused by not having an appropriate plugin, such as "@nx/js" installed, which will add the appropriate "${requiredTargetName}" target for you automatically.`,
+        ].join('\n')}\n`);
+    }
+    /**
+     * Run the relevant nx-release-publish executor on each of the selected projects.
+     */
+    const status = await (0, run_command_1.runCommand)(projectsWithTarget, projectGraph, { nxJson }, {
+        targets: [requiredTargetName],
+        outputStyle: 'static',
+        ...args,
+        // It is possible for workspaces to have circular dependencies between packages and still release them to a registry
+        nxIgnoreCycles: true,
+    }, overrides, null, {}, extraOptions);
+    if (status !== 0) {
+        // In order to not add noise to the overall CLI output, do not throw an additional error
+        if (isCLI) {
+            return status;
+        }
+        // Throw an additional error for programmatic API usage
+        throw new Error('One or more of the selected projects could not be published');
+    }
+    return 0;
+}

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

@@ -0,0 +1,5 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { ReleaseOptions, VersionOptions } from './command-object';
+import { NxReleaseVersionResult } from './version';
+export declare const releaseCLIHandler: (args: VersionOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: ReleaseOptions) => Promise<NxReleaseVersionResult | number>;