@ohos-ports/nx 19.8.4-beta.0

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

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseCLIHandler = void 0;
+exports.createAPI = createAPI;
+const enquirer_1 = require("enquirer");
+const node_fs_1 = require("node:fs");
+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 output_1 = require("../../utils/output");
+const handle_errors_1 = require("../../utils/handle-errors");
+const changelog_1 = require("./changelog");
+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 publish_1 = require("./publish");
+const git_1 = require("./utils/git");
+const github_1 = require("./utils/github");
+const print_config_1 = require("./utils/print-config");
+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, handle_errors_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releaseCLIHandler = releaseCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    const releaseVersion = (0, version_1.createAPI)(overrideReleaseConfig);
+    const releaseChangelog = (0, changelog_1.createAPI)(overrideReleaseConfig);
+    const releasePublish = (0, publish_1.createAPI)(overrideReleaseConfig);
+    return async function release(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 ?? {});
+        const hasVersionGitConfig = Object.keys(userProvidedReleaseConfig.version?.git ?? {}).length > 0;
+        const hasChangelogGitConfig = Object.keys(userProvidedReleaseConfig.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);
+            output_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, 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 rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        if (args.specifier && rawVersionPlans.length > 0) {
+            output_1.output.error({
+                title: `A specifier option cannot be provided when using version plans.`,
+                bodyLines: [
+                    `To override this behavior, use the Nx Release programmatic API directly (https://nx.dev/features/manage-releases#using-the-programmatic-api-for-nx-release).`,
+                ],
+            });
+            process.exit(1);
+        }
+        // These properties must never be undefined as this command should
+        // always explicitly override the git operations of the subcommands.
+        const shouldCommit = userProvidedReleaseConfig.git?.commit ?? true;
+        const shouldStage = (shouldCommit || userProvidedReleaseConfig.git?.stageChanges) ?? false;
+        const shouldTag = userProvidedReleaseConfig.git?.tag ?? true;
+        const versionResult = await releaseVersion({
+            ...args,
+            stageChanges: shouldStage,
+            gitCommit: false,
+            gitTag: false,
+            deleteVersionPlans: false,
+        });
+        const changelogResult = await releaseChangelog({
+            ...args,
+            versionData: versionResult.projectsVersionData,
+            version: versionResult.workspaceVersion,
+            stageChanges: shouldStage,
+            gitCommit: false,
+            gitTag: false,
+            createRelease: false,
+            deleteVersionPlans: false,
+        });
+        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);
+        }
+        await (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes), args.verbose);
+        const planFiles = new Set();
+        releaseGroups.forEach((group) => {
+            if (group.resolvedVersionPlans) {
+                if (group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                    output_1.output.logSingleLine(`Removing version plan files`);
+                }
+                else {
+                    output_1.output.logSingleLine(`Removing version plan files for group ${group.name}`);
+                }
+                group.resolvedVersionPlans.forEach((plan) => {
+                    if (!args.dryRun) {
+                        (0, node_fs_1.rmSync)(plan.absolutePath, { recursive: true, force: true });
+                        if (args.verbose) {
+                            console.log(`Removing ${plan.relativePath}`);
+                        }
+                    }
+                    else {
+                        if (args.verbose) {
+                            console.log(`Would remove ${plan.relativePath}, but --dry-run was set`);
+                        }
+                    }
+                    planFiles.add(plan.relativePath);
+                });
+            }
+        });
+        const deletedFiles = Array.from(planFiles);
+        if (deletedFiles.length > 0) {
+            await (0, git_1.gitAdd)({
+                changedFiles: [],
+                deletedFiles,
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+        }
+        if (shouldCommit) {
+            output_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) {
+            output_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,
+                });
+            }
+        }
+        const shouldCreateWorkspaceRelease = (0, changelog_1.shouldCreateGitHubRelease)(nxReleaseConfig.changelog.workspaceChangelog);
+        let hasPushedChanges = false;
+        let latestCommit;
+        if (shouldCreateWorkspaceRelease && changelogResult.workspaceChangelog) {
+            output_1.output.logSingleLine(`Pushing to git remote`);
+            // Before we can create/update the release we need to ensure the commit exists on the remote
+            await (0, git_1.gitPush)({
+                dryRun: args.dryRun,
+                verbose: args.verbose,
+            });
+            hasPushedChanges = true;
+            output_1.output.logSingleLine(`Creating GitHub Release`);
+            latestCommit = await (0, git_1.getCommitHash)('HEAD');
+            await (0, github_1.createOrUpdateGithubRelease)(nxReleaseConfig.changelog.workspaceChangelog
+                ? nxReleaseConfig.changelog.workspaceChangelog.createRelease
+                : false, changelogResult.workspaceChangelog.releaseVersion, changelogResult.workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+        }
+        for (const releaseGroup of releaseGroups) {
+            const shouldCreateProjectReleases = (0, changelog_1.shouldCreateGitHubRelease)(releaseGroup.changelog);
+            if (shouldCreateProjectReleases && changelogResult.projectChangelogs) {
+                const projects = args.projects?.length
+                    ? // If the user has passed a list of projects, we need to use the filtered list of projects within the release group
+                        Array.from(releaseGroupToFilteredProjects.get(releaseGroup))
+                    : // Otherwise, we use the full list of projects within the release group
+                        releaseGroup.projects;
+                const projectNodes = projects.map((name) => projectGraph.nodes[name]);
+                for (const project of projectNodes) {
+                    const changelog = changelogResult.projectChangelogs[project.name];
+                    if (!changelog) {
+                        continue;
+                    }
+                    if (!hasPushedChanges) {
+                        output_1.output.logSingleLine(`Pushing to git remote`);
+                        // Before we can create/update the release we need to ensure the commit exists on the remote
+                        await (0, git_1.gitPush)({
+                            dryRun: args.dryRun,
+                            verbose: args.verbose,
+                        });
+                        hasPushedChanges = true;
+                    }
+                    output_1.output.logSingleLine(`Creating GitHub Release`);
+                    if (!latestCommit) {
+                        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                    }
+                    await (0, github_1.createOrUpdateGithubRelease)(releaseGroup.changelog
+                        ? releaseGroup.changelog.createRelease
+                        : false, changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
+                }
+            }
+        }
+        let hasNewVersion = false;
+        // null means that all projects are versioned together but there were no changes
+        if (versionResult.workspaceVersion !== null) {
+            hasNewVersion = Object.values(versionResult.projectsVersionData).some((version) => version.newVersion !== null);
+        }
+        let shouldPublish = !!args.yes && !args.skipPublish && hasNewVersion;
+        const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun && hasNewVersion;
+        if (shouldPromptPublishing) {
+            shouldPublish = await promptForPublish();
+        }
+        if (shouldPublish) {
+            await releasePublish(args);
+        }
+        else {
+            output_1.output.logSingleLine('Skipped publishing packages.');
+        }
+        return versionResult;
+    };
+}
+async function promptForPublish() {
+    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) {
+        // 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,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchProjectsByGeneratorConfig = batchProjectsByGeneratorConfig;
+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;
+}

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 = execCommand;
+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',
+            windowsHide: true,
+        });
+        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);
+            }
+        });
+    });
+}

package/src/command-line/release/utils/generate-version-plan-content.d.ts

@@ -0,0 +1 @@
+export declare function generateVersionPlanContent(bumps: Record<string, string>, message: string): string;

package/src/command-line/release/utils/generate-version-plan-content.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVersionPlanContent = generateVersionPlanContent;
+function generateVersionPlanContent(bumps, message) {
+    const frontMatter = `---
+${Object.entries(bumps)
+        .filter(([_, version]) => version !== 'none')
+        .map(([projectOrGroup, version]) => {
+        let key = projectOrGroup;
+        // frontmatter parsing will blow up if we don't wrap @org/package style project names in quotes
+        if (key.startsWith('@')) {
+            key = `'${key}'`;
+        }
+        return `${key}: ${version}`;
+    })
+        .join('\n')}
+---
+`;
+    return `${frontMatter}${message ? `\n${message}\n` : ''}`;
+}

package/src/command-line/release/utils/get-touched-projects-for-group.d.ts

@@ -0,0 +1,7 @@
+import { FileData, ProjectGraph } from '../../../config/project-graph';
+import { NxArgs } from '../../../utils/command-line-utils';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+/**
+ * Create a function that returns the touched projects for a given release group. Only relevant when version plans are enabled.
+ */
+export declare function createGetTouchedProjectsForGroup(nxArgs: NxArgs, projectGraph: ProjectGraph, changedFiles: string[], fileData: FileData[]): (releaseGroup: ReleaseGroupWithName, releaseGroupFilteredProjectNames: string[], hasProjectsFilter: boolean) => Promise<string[]>;

package/src/command-line/release/utils/get-touched-projects-for-group.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetTouchedProjectsForGroup = createGetTouchedProjectsForGroup;
+const workspace_projects_1 = require("../../../project-graph/affected/locators/workspace-projects");
+const file_utils_1 = require("../../../project-graph/file-utils");
+const ignore_1 = require("../../../utils/ignore");
+const output_1 = require("../../../utils/output");
+const config_1 = require("../config/config");
+/**
+ * Create a function that returns the touched projects for a given release group. Only relevant when version plans are enabled.
+ */
+function createGetTouchedProjectsForGroup(nxArgs, projectGraph, changedFiles, fileData) {
+    /**
+     * Create a minimal subset of touched projects based on the configured ignore patterns, we only need
+     * to recompute when the ignorePatternsForPlanCheck differs between release groups.
+     */
+    const serializedIgnorePatternsToTouchedProjects = new Map();
+    return async function getTouchedProjectsForGroup(releaseGroup, 
+    // We don't access releaseGroups.projects directly, because we need to take the --projects filter into account
+    releaseGroupFilteredProjectNames, hasProjectsFilter) {
+        // The current release group doesn't leverage version plans
+        if (!releaseGroup.versionPlans) {
+            return [];
+        }
+        // Exclude patterns from .nxignore, .gitignore and explicit version plan config
+        let serializedIgnorePatterns = '[]';
+        const ignore = (0, ignore_1.getIgnoreObject)();
+        if (typeof releaseGroup.versionPlans !== 'boolean' &&
+            Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+            releaseGroup.versionPlans.ignorePatternsForPlanCheck.length) {
+            output_1.output.note({
+                title: `Applying configured ignore patterns to changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` for release group "${releaseGroup.name}"`
+                    : ''}`,
+                bodyLines: [
+                    ...releaseGroup.versionPlans.ignorePatternsForPlanCheck.map((pattern) => `  - ${pattern}`),
+                ],
+            });
+            ignore.add(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+            serializedIgnorePatterns = JSON.stringify(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+        }
+        let touchedProjects = {};
+        if (serializedIgnorePatternsToTouchedProjects.has(serializedIgnorePatterns)) {
+            touchedProjects = serializedIgnorePatternsToTouchedProjects.get(serializedIgnorePatterns);
+        }
+        else {
+            // We only care about directly touched projects, not implicitly affected ones etc
+            const touchedProjectsArr = await (0, workspace_projects_1.getTouchedProjects)((0, file_utils_1.calculateFileChanges)(changedFiles, fileData, nxArgs, undefined, ignore), projectGraph.nodes);
+            touchedProjects = touchedProjectsArr.reduce((acc, project) => ({ ...acc, [project]: true }), {});
+            serializedIgnorePatternsToTouchedProjects.set(serializedIgnorePatterns, touchedProjects);
+        }
+        const touchedProjectsUnderReleaseGroup = releaseGroupFilteredProjectNames.filter((project) => touchedProjects[project]);
+        if (touchedProjectsUnderReleaseGroup.length) {
+            output_1.output.log({
+                title: `Touched projects${hasProjectsFilter ? ` (after --projects filter applied)` : ''} based on changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` under release group "${releaseGroup.name}"`
+                    : ''}`,
+                bodyLines: [
+                    ...touchedProjectsUnderReleaseGroup.map((project) => `  - ${project}`),
+                    '',
+                    'NOTE: You can adjust your "versionPlans.ignorePatternsForPlanCheck" config to stop certain files from resulting in projects being classed as touched for the purposes of this command.',
+                ],
+            });
+        }
+        else {
+            output_1.output.log({
+                title: `No touched projects${hasProjectsFilter ? ` (after --projects filter applied)` : ''} found based on changed files${typeof releaseGroup.versionPlans !== 'boolean' &&
+                    Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                    releaseGroup.versionPlans.ignorePatternsForPlanCheck.length
+                    ? ' combined with configured ignore patterns'
+                    : ''}${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                    ? ` under release group "${releaseGroup.name}"`
+                    : ''}`,
+            });
+        }
+        return touchedProjectsUnderReleaseGroup;
+    };
+}

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

@@ -0,0 +1,67 @@
+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, deletedFiles, dryRun, verbose, logFn, cwd, }: {
+    changedFiles?: string[];
+    deletedFiles?: string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    cwd?: string;
+    logFn?: (...messages: string[]) => void;
+}): Promise<string>;
+export declare function gitCommit({ messages, additionalArgs, dryRun, verbose, logFn, }: {
+    messages: string[];
+    additionalArgs?: string | 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 | string[];
+    dryRun?: boolean;
+    verbose?: boolean;
+    logFn?: (message: string) => void;
+}): Promise<string>;
+export declare function gitPush({ gitRemote, dryRun, verbose, }: {
+    gitRemote?: string;
+    dryRun?: boolean;
+    verbose?: boolean;
+}): Promise<void>;
+export declare function parseCommits(commits: RawGitCommit[]): GitCommit[];
+export declare function parseConventionalCommitsMessage(message: string): {
+    type: string;
+    scope: string;
+    description: string;
+    breaking: boolean;
+} | null;
+export declare function parseGitCommit(commit: RawGitCommit, isVersionPlanCommit?: boolean): GitCommit | null;
+export declare function getCommitHash(ref: string): Promise<string>;
+export declare function getFirstGitCommit(): Promise<string>;