@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/release/utils/resolve-semver-specifier.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSemverSpecifierFromConventionalCommits = resolveSemverSpecifierFromConventionalCommits;
+exports.resolveSemverSpecifierFromPrompt = resolveSemverSpecifierFromPrompt;
+const enquirer_1 = require("enquirer");
+const semver_1 = require("semver");
+const git_1 = require("./git");
+const semver_2 = require("./semver");
+const shared_1 = require("./shared");
+async function resolveSemverSpecifierFromConventionalCommits(from, projectGraph, projectNames, conventionalCommitsConfig) {
+    const commits = await (0, git_1.getGitDiff)(from);
+    const parsedCommits = (0, git_1.parseCommits)(commits);
+    const relevantCommits = await (0, shared_1.getCommitsRelevantToProjects)(projectGraph, parsedCommits, projectNames);
+    return (0, semver_2.determineSemverChange)(relevantCommits, conventionalCommitsConfig);
+}
+async function resolveSemverSpecifierFromPrompt(selectionMessage, customVersionMessage) {
+    try {
+        const reply = await (0, enquirer_1.prompt)([
+            {
+                name: 'specifier',
+                message: selectionMessage,
+                type: 'select',
+                choices: [
+                    ...semver_1.RELEASE_TYPES.map((t) => ({ name: t, message: t })),
+                    {
+                        name: 'custom',
+                        message: 'Custom exact version',
+                    },
+                ],
+            },
+        ]);
+        if (reply.specifier !== 'custom') {
+            return reply.specifier;
+        }
+        else {
+            const reply = await (0, enquirer_1.prompt)([
+                {
+                    name: 'specifier',
+                    message: customVersionMessage,
+                    type: 'input',
+                    validate: (input) => {
+                        if ((0, semver_1.valid)(input)) {
+                            return true;
+                        }
+                        return 'Please enter a valid semver version';
+                    },
+                },
+            ]);
+            return reply.specifier;
+        }
+    }
+    catch {
+        // TODO: log the error to the user?
+        // We need to catch the error from enquirer prompt, otherwise yargs will print its help
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
+import { ReleaseType } from 'semver';
+import { NxReleaseConfig } from '../config/config';
+import { GitCommit } from './git';
+export declare function isRelativeVersionKeyword(val: string): val is ReleaseType;
+export declare function isValidSemverSpecifier(specifier: string): boolean;
+export declare function determineSemverChange(commits: GitCommit[], config: NxReleaseConfig['conventionalCommits']): 'patch' | 'minor' | 'major' | null;
+export declare function deriveNewSemverVersion(currentSemverVersion: string, semverSpecifier: string, preid?: string): string;

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

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Special thanks to changelogen for the original inspiration for many of these utilities:
+ * https://github.com/unjs/changelogen
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelativeVersionKeyword = isRelativeVersionKeyword;
+exports.isValidSemverSpecifier = isValidSemverSpecifier;
+exports.determineSemverChange = determineSemverChange;
+exports.deriveNewSemverVersion = deriveNewSemverVersion;
+const semver_1 = require("semver");
+function isRelativeVersionKeyword(val) {
+    return semver_1.RELEASE_TYPES.includes(val);
+}
+function isValidSemverSpecifier(specifier) {
+    return (specifier && !!((0, semver_1.valid)(specifier) || isRelativeVersionKeyword(specifier)));
+}
+// https://github.com/unjs/changelogen/blob/main/src/semver.ts
+function determineSemverChange(commits, config) {
+    let [hasMajor, hasMinor, hasPatch] = [false, false, false];
+    for (const commit of commits) {
+        const semverType = config.types[commit.type]?.semverBump;
+        if (semverType === 'major' || commit.isBreaking) {
+            hasMajor = true;
+        }
+        else if (semverType === 'minor') {
+            hasMinor = true;
+        }
+        else if (semverType === 'patch') {
+            hasPatch = true;
+        }
+        else if (semverType === 'none' || !semverType) {
+            // do not report a change
+        }
+    }
+    return hasMajor ? 'major' : hasMinor ? 'minor' : hasPatch ? 'patch' : null;
+}
+function deriveNewSemverVersion(currentSemverVersion, semverSpecifier, preid) {
+    if (!(0, semver_1.valid)(currentSemverVersion)) {
+        throw new Error(`Invalid semver version "${currentSemverVersion}" provided.`);
+    }
+    let newVersion = semverSpecifier;
+    if (isRelativeVersionKeyword(semverSpecifier)) {
+        // Derive the new version from the current version combined with the new version specifier.
+        const derivedVersion = (0, semver_1.inc)(currentSemverVersion, semverSpecifier, preid);
+        if (!derivedVersion) {
+            throw new Error(`Unable to derive new version from current version "${currentSemverVersion}" and version specifier "${semverSpecifier}"`);
+        }
+        newVersion = derivedVersion;
+    }
+    else {
+        // Ensure the new version specifier is a valid semver version, given it is not a valid semver keyword
+        if (!(0, semver_1.valid)(semverSpecifier)) {
+            throw new Error(`Invalid semver version specifier "${semverSpecifier}" provided. Please provide either a valid semver version or a valid semver version keyword.`);
+        }
+    }
+    return newVersion;
+}

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

@@ -0,0 +1,53 @@
+import { ProjectGraph } from '../../../config/project-graph';
+import { Tree } from '../../../generators/tree';
+import type { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { GitCommit } from './git';
+export declare const noDiffInChangelogMessage: string;
+export type ReleaseVersionGeneratorResult = {
+    data: VersionData;
+    callback: (tree: Tree, opts: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        generatorOptions?: Record<string, unknown>;
+    }) => Promise<string[] | {
+        changedFiles: string[];
+        deletedFiles: string[];
+    }>;
+};
+export type VersionData = Record<string, {
+    /**
+     * newVersion will be null in the case that no changes are detected for the project,
+     * e.g. when using conventional commits
+     */
+    newVersion: string | null;
+    currentVersion: string;
+    /**
+     * The list of projects which depend upon the current project.
+     * TODO: investigate generic type for this once more ecosystems are explored
+     */
+    dependentProjects: any[];
+}>;
+export declare class ReleaseVersion {
+    rawVersion: string;
+    gitTag: string;
+    isPrerelease: boolean;
+    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
+    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
+    projectName, }: {
+        version: string;
+        releaseTagPattern: string;
+        projectName?: string;
+    });
+}
+export declare function commitChanges({ changedFiles, deletedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs, }: {
+    changedFiles?: string[];
+    deletedFiles?: string[];
+    isDryRun?: boolean;
+    isVerbose?: boolean;
+    gitCommitMessages?: string[];
+    gitCommitArgs?: string | string[];
+}): Promise<void>;
+export declare function createCommitMessageValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData, commitMessage: string): string[];
+export declare function createGitTagValues(releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, versionData: VersionData): string[];
+export declare function handleDuplicateGitTags(gitTagValues: string[]): void;
+export declare function getCommitsRelevantToProjects(projectGraph: ProjectGraph, commits: GitCommit[], projects: string[]): Promise<GitCommit[]>;

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

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseVersion = exports.noDiffInChangelogMessage = void 0;
+exports.commitChanges = commitChanges;
+exports.createCommitMessageValues = createCommitMessageValues;
+exports.createGitTagValues = createGitTagValues;
+exports.handleDuplicateGitTags = handleDuplicateGitTags;
+exports.getCommitsRelevantToProjects = getCommitsRelevantToProjects;
+const chalk = require("chalk");
+const semver_1 = require("semver");
+const file_map_utils_1 = require("../../../project-graph/file-map-utils");
+const utils_1 = require("../../../tasks-runner/utils");
+const output_1 = require("../../../utils/output");
+const git_1 = require("./git");
+exports.noDiffInChangelogMessage = chalk.yellow(`NOTE: There was no diff detected for the changelog entry. Maybe you intended to pass alternative git references via --from and --to?`);
+function isPrerelease(version) {
+    // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
+    return (0, semver_1.prerelease)(version) !== null;
+}
+class ReleaseVersion {
+    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
+    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
+    projectName, // optional project name to interpolate into the releaseTagPattern
+     }) {
+        this.rawVersion = version;
+        this.gitTag = (0, utils_1.interpolate)(releaseTagPattern, {
+            version,
+            projectName,
+        });
+        this.isPrerelease = isPrerelease(version);
+    }
+}
+exports.ReleaseVersion = ReleaseVersion;
+async function commitChanges({ changedFiles, deletedFiles, isDryRun, isVerbose, gitCommitMessages, gitCommitArgs, }) {
+    if (!changedFiles?.length && !deletedFiles?.length) {
+        throw new Error('Error: No changed files to commit');
+    }
+    output_1.output.logSingleLine(`Committing changes with git`);
+    await (0, git_1.gitAdd)({
+        changedFiles,
+        deletedFiles,
+        dryRun: isDryRun,
+        verbose: isVerbose,
+    });
+    // The extra logs need something breathing room
+    if (isVerbose) {
+        console.log('');
+    }
+    await (0, git_1.gitCommit)({
+        messages: gitCommitMessages,
+        additionalArgs: gitCommitArgs,
+        dryRun: isDryRun,
+        verbose: isVerbose,
+    });
+}
+function createCommitMessageValues(releaseGroups, releaseGroupToFilteredProjects, versionData, commitMessage) {
+    const commitMessageValues = [commitMessage];
+    if (releaseGroups.length === 0) {
+        return commitMessageValues;
+    }
+    // If we have exactly one release group, with a fixed relationship, then interpolate {version} as the new version for the release group
+    if (releaseGroups.length === 1 &&
+        releaseGroups[0].projectsRelationship === 'fixed') {
+        const releaseGroup = releaseGroups[0];
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
+        const releaseVersion = new ReleaseVersion({
+            version: projectVersionData.newVersion,
+            releaseTagPattern: releaseGroup.releaseTagPattern,
+        });
+        commitMessageValues[0] = (0, utils_1.interpolate)(commitMessageValues[0], {
+            version: releaseVersion.rawVersion,
+        }).trim();
+        return commitMessageValues;
+    }
+    /**
+     * There is another special case for interpolation: if, after all filtering, we have a single independent release group with a single project,
+     * and the user has provided {projectName} within the custom message.
+     * In this case we will directly interpolate both {version} and {projectName} within the commit message.
+     */
+    if (releaseGroups.length === 1 &&
+        releaseGroups[0].projectsRelationship === 'independent' &&
+        commitMessage.includes('{projectName}')) {
+        const releaseGroup = releaseGroups[0];
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        if (releaseGroupProjectNames.length === 1) {
+            const projectVersionData = versionData[releaseGroupProjectNames[0]];
+            const releaseVersion = new ReleaseVersion({
+                version: projectVersionData.newVersion,
+                releaseTagPattern: releaseGroup.releaseTagPattern,
+                projectName: releaseGroupProjectNames[0],
+            });
+            commitMessageValues[0] = (0, utils_1.interpolate)(commitMessageValues[0], {
+                version: releaseVersion.rawVersion,
+                projectName: releaseGroupProjectNames[0],
+            }).trim();
+            return commitMessageValues;
+        }
+    }
+    /**
+     * At this point we have multiple release groups for a single commit, we will not interpolate an overall {version} or {projectName} because that won't be
+     * appropriate (for any {version} or {projectName} value within the string, we will replace it with an empty string so that it doesn't end up in the final output).
+     *
+     * Instead for fixed groups we will add one bullet point the release group, and for independent groups we will add one bullet point per project.
+     */
+    commitMessageValues[0] = stripPlaceholders(commitMessageValues[0], [
+        // for cleanest possible final result try and replace the common pattern of a v prefix in front of the version first
+        'v{version}',
+        '{version}',
+        '{projectName}',
+    ]);
+    for (const releaseGroup of releaseGroups) {
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        // One entry per project for independent groups
+        if (releaseGroup.projectsRelationship === 'independent') {
+            for (const project of releaseGroupProjectNames) {
+                const projectVersionData = versionData[project];
+                if (projectVersionData.newVersion !== null) {
+                    const releaseVersion = new ReleaseVersion({
+                        version: projectVersionData.newVersion,
+                        releaseTagPattern: releaseGroup.releaseTagPattern,
+                        projectName: project,
+                    });
+                    commitMessageValues.push(`- project: ${project} ${releaseVersion.rawVersion}`);
+                }
+            }
+            continue;
+        }
+        // One entry for the whole group for fixed groups
+        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
+        if (projectVersionData.newVersion !== null) {
+            const releaseVersion = new ReleaseVersion({
+                version: projectVersionData.newVersion,
+                releaseTagPattern: releaseGroup.releaseTagPattern,
+            });
+            commitMessageValues.push(`- release-group: ${releaseGroup.name} ${releaseVersion.rawVersion}`);
+        }
+    }
+    return commitMessageValues;
+}
+function stripPlaceholders(str, placeholders) {
+    for (const placeholder of placeholders) {
+        // for cleanest possible final result try and replace relevant spacing around placeholders first
+        str = str
+            .replace(` ${placeholder}`, '')
+            .replace(`${placeholder} `, '')
+            .replace(placeholder, '')
+            .trim();
+    }
+    return str;
+}
+function createGitTagValues(releaseGroups, releaseGroupToFilteredProjects, versionData) {
+    const tags = [];
+    for (const releaseGroup of releaseGroups) {
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        // For independent groups we want one tag per project, not one for the overall group
+        if (releaseGroup.projectsRelationship === 'independent') {
+            for (const project of releaseGroupProjectNames) {
+                const projectVersionData = versionData[project];
+                if (projectVersionData.newVersion !== null) {
+                    tags.push((0, utils_1.interpolate)(releaseGroup.releaseTagPattern, {
+                        version: projectVersionData.newVersion,
+                        projectName: project,
+                    }));
+                }
+            }
+            continue;
+        }
+        // For fixed groups we want one tag for the overall group
+        const projectVersionData = versionData[releaseGroupProjectNames[0]]; // all at the same version, so we can just pick the first one
+        if (projectVersionData.newVersion !== null) {
+            tags.push((0, utils_1.interpolate)(releaseGroup.releaseTagPattern, {
+                version: projectVersionData.newVersion,
+                releaseGroupName: releaseGroup.name,
+            }));
+        }
+    }
+    return tags;
+}
+function findDuplicates(arr) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const item of arr) {
+        if (seen.has(item)) {
+            duplicates.add(item);
+        }
+        else {
+            seen.add(item);
+        }
+    }
+    return Array.from(duplicates);
+}
+function handleDuplicateGitTags(gitTagValues) {
+    // If any of the gitTagValues are identical we should hard error upfront to avoid an awkward git error later
+    const duplicateGitTagValues = findDuplicates(gitTagValues);
+    if (duplicateGitTagValues.length) {
+        output_1.output.error({
+            title: `Your current configuration would generate the following duplicate git tags:`,
+            bodyLines: [
+                ...duplicateGitTagValues.map((v) => `- ${v}`),
+                '',
+                `Please ensure that for "independent" release groups the {projectName} placeholder is used so that all dynamically created project tags are unique.`,
+            ],
+        });
+        process.exit(1);
+    }
+}
+async function getCommitsRelevantToProjects(projectGraph, commits, projects) {
+    const { fileMap } = await (0, file_map_utils_1.createFileMapUsingProjectGraph)(projectGraph);
+    const filesInReleaseGroup = new Set(projects.reduce((files, p) => [...files, ...fileMap.projectFileMap[p].map((f) => f.file)], []));
+    /**
+     * The relevant commits are those that either:
+     * - touch project files which are contained within the list of projects directly
+     * - touch non-project files and the commit is not scoped
+     */
+    return commits.filter((c) => c.affectedFiles.some((f) => filesInReleaseGroup.has(f) ||
+        (!c.scope &&
+            fileMap.nonProjectFiles.some((nonProjectFile) => nonProjectFile.file === f))));
+}

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

@@ -0,0 +1,60 @@
+import { NxReleaseConfiguration } from '../../config/nx-json';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { VersionOptions } from './command-object';
+import { NxReleaseConfig } from './config/config';
+import { ReleaseGroupWithName } from './config/filter-release-groups';
+import { VersionData } from './utils/shared';
+export { deriveNewSemverVersion } from './utils/semver';
+export type { ReleaseVersionGeneratorResult, VersionData, } from './utils/shared';
+export declare const validReleaseVersionPrefixes: readonly ["auto", "", "~", "^", "="];
+export interface ReleaseVersionGeneratorSchema {
+    projects: ProjectGraphProjectNode[];
+    releaseGroup: ReleaseGroupWithName;
+    projectGraph: ProjectGraph;
+    specifier?: string;
+    specifierSource?: 'prompt' | 'conventional-commits' | 'version-plans';
+    preid?: string;
+    packageRoot?: string;
+    currentVersionResolver?: 'registry' | 'disk' | 'git-tag';
+    currentVersionResolverMetadata?: Record<string, unknown>;
+    fallbackCurrentVersionResolver?: 'disk';
+    firstRelease?: boolean;
+    versionPrefix?: (typeof validReleaseVersionPrefixes)[number];
+    skipLockFileUpdate?: boolean;
+    installArgs?: string;
+    installIgnoreScripts?: boolean;
+    conventionalCommitsConfig?: NxReleaseConfig['conventionalCommits'];
+    deleteVersionPlans?: boolean;
+    /**
+     * 'auto' allows users to opt into dependents being updated (a patch version bump) when a dependency is versioned.
+     * This is only applicable to independently released projects.
+     */
+    updateDependents?: 'never' | 'auto';
+    /**
+     * Whether or not to completely omit project logs when that project has no applicable changes. This can be useful for
+     * large monorepos which have a large number of projects, especially when only a subset are released together.
+     */
+    logUnchangedProjects?: boolean;
+    /**
+     * Whether or not to keep local dependency protocols (e.g. file:, workspace:) when updating dependencies in
+     * package.json files. This is `false` by default as not all package managers support publishing with these protocols
+     * still present in the package.json.
+     */
+    preserveLocalDependencyProtocols?: boolean;
+}
+export interface NxReleaseVersionResult {
+    /**
+     * In one specific (and very common) case, an overall workspace version is relevant, for example when there is
+     * only a single release group in which all projects have a fixed relationship to each other. In this case, the
+     * overall workspace version is the same as the version of the release group (and every project within it). This
+     * version could be a `string`, or it could be `null` if using conventional commits and no changes were detected.
+     *
+     * In all other cases (independent versioning, multiple release groups etc), the overall workspace version is
+     * not applicable and will be `undefined` here. If a user attempts to use this value later when it is `undefined`
+     * (for example in the changelog command), we will throw an appropriate error.
+     */
+    workspaceVersion: (string | null) | undefined;
+    projectsVersionData: VersionData;
+}
+export declare const releaseVersionCLIHandler: (args: VersionOptions) => Promise<number>;
+export declare function createAPI(overrideReleaseConfig: NxReleaseConfiguration): (args: VersionOptions) => Promise<NxReleaseVersionResult>;