@ohos-ports/nx 17.3.2-beta.0

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.releaseVersion = exports.releasePublish = exports.releaseChangelog = void 0;
+/**
+ * @public
+ */
+var changelog_1 = require("./changelog");
+Object.defineProperty(exports, "releaseChangelog", { enumerable: true, get: function () { return changelog_1.releaseChangelog; } });
+/**
+ * @public
+ */
+var publish_1 = require("./publish");
+Object.defineProperty(exports, "releasePublish", { enumerable: true, get: function () { return publish_1.releasePublish; } });
+/**
+ * @public
+ */
+var version_1 = require("./version");
+Object.defineProperty(exports, "releaseVersion", { enumerable: true, get: function () { return version_1.releaseVersion; } });
+/**
+ * @public
+ */
+var release_1 = require("./release");
+Object.defineProperty(exports, "release", { enumerable: true, get: function () { return release_1.release; } });

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

@@ -0,0 +1,8 @@
+import { PublishOptions } from './command-object';
+export declare const releasePublishCLIHandler: (args: PublishOptions) => Promise<any>;
+/**
+ * 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.
+ */
+export declare function releasePublish(args: PublishOptions, isCLI?: boolean): Promise<number>;

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePublish = exports.releasePublishCLIHandler = void 0;
+const nx_json_1 = require("../../config/nx-json");
+const devkit_exports_1 = require("../../devkit-exports");
+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 logger_1 = require("../../utils/logger");
+const params_1 = require("../../utils/params");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const graph_1 = require("../graph/graph");
+const config_1 = require("./config/config");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const releasePublishCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => releasePublish(args, true));
+exports.releasePublishCLIHandler = releasePublishCLIHandler;
+/**
+ * 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.
+ */
+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)();
+    if (_args.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    // Apply default configuration to any optional user configuration
+    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, nxJson.release);
+    if (configError) {
+        return await (0, config_1.handleNxReleaseConfigError)(configError);
+    }
+    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, _args.projects, _args.groups);
+    if (filterError) {
+        devkit_exports_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;
+    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)), shouldExcludeTaskDependencies, isCLI);
+            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, shouldExcludeTaskDependencies, isCLI);
+        if (status !== 0) {
+            overallExitStatus = status || 1;
+        }
+    }
+    if (_args.dryRun) {
+        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no projects were actually published.`);
+    }
+    return overallExitStatus;
+}
+exports.releasePublish = releasePublish;
+async function runPublishOnProjects(args, projectGraph, nxJson, projectNames, shouldExcludeTaskDependencies, isCLI) {
+    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.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.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    if (args.firstRelease) {
+        overrides.firstRelease = args.firstRelease;
+    }
+    const targets = ['nx-release-publish'];
+    if (args.graph) {
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(args);
+        const projectNames = projectsToRun.map((t) => t.name);
+        await (0, graph_1.generateGraph)({
+            watch: false,
+            all: false,
+            open: true,
+            view: 'tasks',
+            targets,
+            projects: projectNames,
+            file,
+        }, projectNames);
+        return 0;
+    }
+    const requiredTargetName = 'nx-release-publish';
+    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,
+        outputStyle: 'static',
+        ...args,
+    }, overrides, null, {}, {
+        excludeTaskDependencies: shouldExcludeTaskDependencies,
+        loadDotEnvFiles: true,
+    });
+    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,4 @@
+import { ReleaseOptions, VersionOptions } from './command-object';
+import { NxReleaseVersionResult } from './version';
+export declare const releaseCLIHandler: (args: VersionOptions) => Promise<any>;
+export declare function release(args: ReleaseOptions): Promise<NxReleaseVersionResult | number>;

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.release = exports.releaseCLIHandler = void 0;
+const enquirer_1 = require("enquirer");
+const nx_json_1 = require("../../config/nx-json");
+const devkit_exports_1 = require("../../devkit-exports");
+const project_graph_1 = require("../../project-graph/project-graph");
+const params_1 = require("../../utils/params");
+const changelog_1 = require("./changelog");
+const config_1 = require("./config/config");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const publish_1 = require("./publish");
+const git_1 = require("./utils/git");
+const resolve_nx_json_error_message_1 = require("./utils/resolve-nx-json-error-message");
+const shared_1 = require("./utils/shared");
+const version_1 = require("./version");
+const releaseCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => release(args));
+exports.releaseCLIHandler = releaseCLIHandler;
+async function release(args) {
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const nxJson = (0, nx_json_1.readNxJson)();
+    if (args.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    const hasVersionGitConfig = Object.keys(nxJson.release?.version?.git ?? {}).length > 0;
+    const hasChangelogGitConfig = Object.keys(nxJson.release?.changelog?.git ?? {}).length > 0;
+    if (hasVersionGitConfig || hasChangelogGitConfig) {
+        const jsonConfigErrorPath = hasVersionGitConfig
+            ? ['release', 'version', 'git']
+            : ['release', 'changelog', 'git'];
+        const nxJsonMessage = await (0, resolve_nx_json_error_message_1.resolveNxJsonConfigErrorMessage)(jsonConfigErrorPath);
+        devkit_exports_1.output.error({
+            title: `The "release" top level command cannot be used with granular git configuration. Instead, configure git options in the "release.git" property in nx.json, or use the version, changelog, and publish subcommands or programmatic API directly.`,
+            bodyLines: [nxJsonMessage],
+        });
+        process.exit(1);
+    }
+    // Apply default configuration to any optional user configuration
+    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, nxJson.release);
+    if (configError) {
+        return await (0, config_1.handleNxReleaseConfigError)(configError);
+    }
+    // These properties must never be undefined as this command should
+    // always explicitly override the git operations of the subcommands.
+    const shouldCommit = nxJson.release?.git?.commit ?? true;
+    const shouldStage = (shouldCommit || nxJson.release?.git?.stageChanges) ?? false;
+    const shouldTag = nxJson.release?.git?.tag ?? true;
+    const versionResult = await (0, version_1.releaseVersion)({
+        ...args,
+        stageChanges: shouldStage,
+        gitCommit: false,
+        gitTag: false,
+    });
+    await (0, changelog_1.releaseChangelog)({
+        ...args,
+        versionData: versionResult.projectsVersionData,
+        version: versionResult.workspaceVersion,
+        stageChanges: shouldStage,
+        gitCommit: false,
+        gitTag: false,
+    });
+    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+    if (filterError) {
+        devkit_exports_1.output.error(filterError);
+        process.exit(1);
+    }
+    if (shouldCommit) {
+        devkit_exports_1.output.logSingleLine(`Committing changes with git`);
+        const commitMessage = nxReleaseConfig.git.commitMessage;
+        const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionResult.projectsVersionData, commitMessage);
+        await (0, git_1.gitCommit)({
+            messages: commitMessageValues,
+            additionalArgs: nxReleaseConfig.git.commitArgs,
+            dryRun: args.dryRun,
+            verbose: args.verbose,
+        });
+    }
+    if (shouldTag) {
+        devkit_exports_1.output.logSingleLine(`Tagging commit with git`);
+        // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
+        const gitTagValues = (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionResult.projectsVersionData);
+        (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+        for (const tag of gitTagValues) {
+            await (0, git_1.gitTag)({
+                tag,
+                message: nxReleaseConfig.git.tagMessage,
+                additionalArgs: nxReleaseConfig.git.tagArgs,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
+    }
+    let shouldPublish = !!args.yes && !args.skipPublish;
+    const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun;
+    if (shouldPromptPublishing) {
+        shouldPublish = await promptForPublish();
+    }
+    if (shouldPublish) {
+        await (0, publish_1.releasePublish)(args);
+    }
+    else {
+        console.log('Skipped publishing packages.');
+    }
+    return versionResult;
+}
+exports.release = release;
+async function promptForPublish() {
+    console.log('\n');
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'confirmation',
+                message: 'Do you want to publish these versions?',
+                type: 'confirm',
+            },
+        ]);
+        return reply.confirmation;
+    }
+    catch (e) {
+        console.log('\n');
+        // Handle the case where the user exits the prompt with ctrl+c
+        return false;
+    }
+}

package/src/command-line/release/utils/batch-projects-by-generator-config.d.ts

@@ -0,0 +1,7 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+/**
+ * To be most efficient with our invocations of runVersionOnProjects, we want to batch projects by their generator and generator options
+ * within any given release group.
+ */
+export declare function batchProjectsByGeneratorConfig(projectGraph: ProjectGraph, releaseGroup: ReleaseGroupWithName, projectNamesToBatch: string[]): Map<string, string[]>;

package/src/command-line/release/utils/batch-projects-by-generator-config.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchProjectsByGeneratorConfig = void 0;
+const json_diff_1 = require("../../../utils/json-diff");
+/**
+ * To be most efficient with our invocations of runVersionOnProjects, we want to batch projects by their generator and generator options
+ * within any given release group.
+ */
+function batchProjectsByGeneratorConfig(projectGraph, releaseGroup, projectNamesToBatch) {
+    const configBatches = new Map();
+    for (const projectName of projectNamesToBatch) {
+        const project = projectGraph.nodes[projectName];
+        const generator = project.data.release?.version?.generator ||
+            releaseGroup.version.generator;
+        const generatorOptions = {
+            ...releaseGroup.version.generatorOptions,
+            ...project.data.release?.version?.generatorOptions,
+        };
+        let found = false;
+        for (const [key, projects] of configBatches) {
+            const [existingGenerator, existingOptions] = JSON.parse(key);
+            if (generator === existingGenerator &&
+                (0, json_diff_1.deepEquals)(generatorOptions, existingOptions)) {
+                projects.push(projectName);
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            configBatches.set(JSON.stringify([generator, generatorOptions]), [
+                projectName,
+            ]);
+        }
+    }
+    return configBatches;
+}
+exports.batchProjectsByGeneratorConfig = batchProjectsByGeneratorConfig;

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

@@ -0,0 +1 @@
+export declare function execCommand(cmd: string, args: string[], options?: any): Promise<string>;

package/src/command-line/release/utils/exec-command.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execCommand = void 0;
+const node_child_process_1 = require("node:child_process");
+async function execCommand(cmd, args, options) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(cmd, args, {
+            ...options,
+            stdio: ['pipe', 'pipe', 'pipe'], // stdin, stdout, stderr
+            encoding: 'utf-8',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(stderr ||
+                    `Unknown error occurred while running "${cmd} ${args.join(' ')}"`);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}
+exports.execCommand = execCommand;

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

@@ -0,0 +1,55 @@
+export interface GitCommitAuthor {
+    name: string;
+    email: string;
+}
+export interface RawGitCommit {
+    message: string;
+    body: string;
+    shortHash: string;
+    author: GitCommitAuthor;
+}
+export interface Reference {
+    type: 'hash' | 'issue' | 'pull-request';
+    value: string;
+}
+export interface GitCommit extends RawGitCommit {
+    description: string;
+    type: string;
+    scope: string;
+    references: Reference[];
+    authors: GitCommitAuthor[];
+    isBreaking: boolean;
+    affectedFiles: string[];
+    revertedHashes: string[];
+}
+export declare function getLatestGitTagForPattern(releaseTagPattern: string, additionalInterpolationData?: {}): Promise<{
+    tag: string;
+    extractedVersion: string;
+} | null>;
+export declare function getGitDiff(from: string | undefined, to?: string): Promise<RawGitCommit[]>;
+export declare function gitAdd({ changedFiles, dryRun, verbose, logFn, }: {
+    changedFiles: string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (...messages: string[]) => void;
+}): Promise<string>;
+export declare function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }: {
+    messages: string[];
+    additionalArgs?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, }: {
+    tag: string;
+    message?: string;
+    additionalArgs?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitPush(gitRemote?: string): Promise<void>;
+export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
+export declare function parseGitCommit(commit: RawGitCommit): GitCommit | null;
+export declare function getCommitHash(ref: string): Promise<string>;
+export declare function getFirstGitCommit(): Promise<string>;