nx 21.0.0-beta.11 → 21.0.0-beta.12

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultCreateReleaseProvider = exports.DEFAULT_VERSION_ACTIONS_PATH = exports.IMPLICIT_DEFAULT_RELEASE_GROUP = void 0;
+exports.DEFAULT_VERSION_ACTIONS_PATH = exports.IMPLICIT_DEFAULT_RELEASE_GROUP = void 0;
 exports.createNxReleaseConfig = createNxReleaseConfig;
 exports.handleNxReleaseConfigError = handleNxReleaseConfigError;
 /**
@@ -23,6 +23,8 @@ const find_matching_projects_1 = require("../../../utils/find-matching-projects"
 const output_1 = require("../../../utils/output");
 const path_1 = require("../../../utils/path");
 const workspace_root_1 = require("../../../utils/workspace-root");
+const github_1 = require("../utils/remote-release-clients/github");
+const gitlab_1 = require("../utils/remote-release-clients/gitlab");
 const resolve_changelog_renderer_1 = require("../utils/resolve-changelog-renderer");
 const resolve_nx_json_error_message_1 = require("../utils/resolve-nx-json-error-message");
 const conventional_commits_1 = require("./conventional-commits");
@@ -170,7 +172,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
                     renderer: defaultRendererPath,
                     renderOptions: {
                         authors: true,
-                        mapAuthorsToGitHubUsernames: true,
+                        applyUsernameToAuthors: true,
                         commitReferences: true,
                         versionTitleDate: true,
                     },
@@ -184,7 +186,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
                     renderer: defaultRendererPath,
                     renderOptions: {
                         authors: true,
-                        mapAuthorsToGitHubUsernames: true,
+                        applyUsernameToAuthors: true,
                         commitReferences: true,
                         versionTitleDate: true,
                     },
@@ -225,7 +227,7 @@ async function createNxReleaseConfig(projectGraph, projectFileMap, userConfig =
             renderer: defaultRendererPath,
             renderOptions: {
                 authors: true,
-                mapAuthorsToGitHubUsernames: true,
+                applyUsernameToAuthors: true,
                 commitReferences: true,
                 versionTitleDate: true,
             },
@@ -930,13 +932,11 @@ const supportedCreateReleaseProviders = [
         name: 'github-enterprise-server',
         defaultApiBaseUrl: 'https://__hostname__/api/v3',
     },
+    {
+        name: 'gitlab',
+        defaultApiBaseUrl: 'https://__hostname__/api/v4',
+    },
 ];
-// User opts into the default by specifying the string value 'github'
-exports.defaultCreateReleaseProvider = {
-    provider: 'github',
-    hostname: 'github.com',
-    apiBaseUrl: 'https://api.github.com',
-};
 function validateCreateReleaseConfig(changelogConfig) {
     const createRelease = changelogConfig.createRelease;
     // Disabled: valid
@@ -945,7 +945,14 @@ function validateCreateReleaseConfig(changelogConfig) {
     }
     // GitHub shorthand, expand to full object form, mark as valid
     if (createRelease === 'github') {
-        changelogConfig.createRelease = exports.defaultCreateReleaseProvider;
+        changelogConfig.createRelease =
+            github_1.defaultCreateReleaseProvider;
+        return null;
+    }
+    // Gitlab shorthand, expand to full object form, mark as valid
+    if (createRelease === 'gitlab') {
+        changelogConfig.createRelease =
+            gitlab_1.defaultCreateReleaseProvider;
         return null;
     }
     // Object config, ensure that properties are valid

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

@@ -17,8 +17,8 @@ const use_legacy_versioning_1 = require("./config/use-legacy-versioning");
 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 remote_release_client_1 = require("./utils/remote-release-clients/remote-release-client");
 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");
@@ -84,10 +84,10 @@ function createAPI(overrideReleaseConfig) {
         const shouldCommit = userProvidedReleaseConfig.git?.commit ?? true;
         const shouldStage = (shouldCommit || userProvidedReleaseConfig.git?.stageChanges) ?? false;
         const shouldTag = userProvidedReleaseConfig.git?.tag ?? true;
-        const shouldCreateWorkspaceRelease = (0, changelog_1.shouldCreateGitHubRelease)(nxReleaseConfig.changelog.workspaceChangelog);
-        // If the workspace or any of the release groups specify that a github release should be created, we need to push the changes to the remote
-        const shouldPush = (shouldCreateWorkspaceRelease ||
-            releaseGroups.some((group) => (0, changelog_1.shouldCreateGitHubRelease)(group.changelog))) ??
+        const shouldCreateWorkspaceRemoteRelease = shouldCreateRemoteRelease(nxReleaseConfig.changelog.workspaceChangelog);
+        // If the workspace or any of the release groups specify that a remote release should be created, we need to push the changes to the remote
+        const shouldPush = (shouldCreateWorkspaceRemoteRelease ||
+            releaseGroups.some((group) => shouldCreateRemoteRelease(group.changelog))) ??
             false;
         const versionResult = await releaseVersion({
             ...args,
@@ -179,19 +179,27 @@ function createAPI(overrideReleaseConfig) {
             hasPushedChanges = true;
         }
         let latestCommit;
-        if (shouldCreateWorkspaceRelease && changelogResult.workspaceChangelog) {
+        if (shouldCreateWorkspaceRemoteRelease &&
+            changelogResult.workspaceChangelog) {
+            const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
+            // shouldCreateWorkspaceRemoteRelease() ensures that the createRelease property exists and is not false
+            nxReleaseConfig.changelog.workspaceChangelog
+                .createRelease);
             if (!hasPushedChanges) {
-                throw new Error('It is not possible to create a github release for the workspace without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config');
+                throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the workspace without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
             }
-            output_1.output.logSingleLine(`Creating GitHub Release`);
+            output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} 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 });
+            await remoteReleaseClient.createOrUpdateRelease(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 shouldCreateProjectRemoteReleases = shouldCreateRemoteRelease(releaseGroup.changelog);
+            if (shouldCreateProjectRemoteReleases &&
+                changelogResult.projectChangelogs) {
+                const remoteReleaseClient = await (0, remote_release_client_1.createRemoteReleaseClient)(
+                // shouldCreateProjectRemoteReleases() ensures that the createRelease property exists and is not false
+                releaseGroup.changelog
+                    .createRelease);
                 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))
@@ -204,15 +212,13 @@ function createAPI(overrideReleaseConfig) {
                         continue;
                     }
                     if (!hasPushedChanges) {
-                        throw new Error('It is not possible to create a github release for the project without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config');
+                        throw new Error(`It is not possible to create a ${remoteReleaseClient.remoteReleaseProviderName} release for the project without pushing the changes to the remote, please ensure that you have not disabled git push in your nx release config`);
                     }
-                    output_1.output.logSingleLine(`Creating GitHub Release`);
+                    output_1.output.logSingleLine(`Creating ${remoteReleaseClient.remoteReleaseProviderName} 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 });
+                    await remoteReleaseClient.createOrUpdateRelease(changelog.releaseVersion, changelog.contents, latestCommit, { dryRun: args.dryRun });
                 }
             }
         }
@@ -253,3 +259,9 @@ async function promptForPublish() {
         return false;
     }
 }
+function shouldCreateRemoteRelease(changelogConfig) {
+    if (changelogConfig === false) {
+        return false;
+    }
+    return changelogConfig.createRelease !== false;
+}

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

@@ -63,6 +63,7 @@ export declare function parseConventionalCommitsMessage(message: string): {
     description: string;
     breaking: boolean;
 } | null;
+export declare function extractReferencesFromCommit(commit: RawGitCommit): Reference[];
 export declare function parseGitCommit(commit: RawGitCommit, isVersionPlanCommit?: boolean): GitCommit | null;
 export declare function getCommitHash(ref: string): Promise<string>;
 export declare function getFirstGitCommit(): Promise<string>;

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

@@ -8,6 +8,7 @@ exports.gitTag = gitTag;
 exports.gitPush = gitPush;
 exports.parseCommits = parseCommits;
 exports.parseConventionalCommitsMessage = parseConventionalCommitsMessage;
+exports.extractReferencesFromCommit = extractReferencesFromCommit;
 exports.parseGitCommit = parseGitCommit;
 exports.getCommitHash = getCommitHash;
 exports.getFirstGitCommit = getFirstGitCommit;
@@ -362,17 +363,32 @@ function parseConventionalCommitsMessage(message) {
         breaking: Boolean(match.groups.breaking),
     };
 }
-function extractReferencesFromCommitMessage(message, shortHash) {
+function extractReferencesFromCommit(commit) {
     const references = [];
-    for (const m of message.matchAll(PullRequestRE)) {
+    // Extract GitHub style PR references from commit message
+    for (const m of commit.message.matchAll(PullRequestRE)) {
         references.push({ type: 'pull-request', value: m[1] });
     }
-    for (const m of message.matchAll(IssueRE)) {
+    // Extract GitLab style merge request references from commit body
+    for (const m of commit.body.matchAll(GitLabMergeRequestRE)) {
+        if (m[1]) {
+            references.push({ type: 'pull-request', value: m[1] });
+        }
+    }
+    // Extract issue references from commit message
+    for (const m of commit.message.matchAll(IssueRE)) {
+        if (!references.some((i) => i.value === m[1])) {
+            references.push({ type: 'issue', value: m[1] });
+        }
+    }
+    // Extract issue references from commit body
+    for (const m of commit.body.matchAll(IssueRE)) {
         if (!references.some((i) => i.value === m[1])) {
             references.push({ type: 'issue', value: m[1] });
         }
     }
-    references.push({ value: shortHash, type: 'hash' });
+    // Add commit hash reference
+    references.push({ value: commit.shortHash, type: 'hash' });
     return references;
 }
 function getAllAuthorsForCommit(commit) {
@@ -390,7 +406,10 @@ function getAllAuthorsForCommit(commit) {
 // https://regex101.com/r/FSfNvA/1
 const ConventionalCommitRegex = /(?<type>[a-z]+)(\((?<scope>.+)\))?(?<breaking>!)?: (?<description>.+)/i;
 const CoAuthoredByRegex = /co-authored-by:\s*(?<name>.+)(<(?<email>.+)>)/gim;
+// GitHub style PR references
 const PullRequestRE = /\([ a-z]*(#\d+)\s*\)/gm;
+// GitLab style merge request references
+const GitLabMergeRequestRE = /See merge request (?:[a-z0-9/-]+)?(![\d]+)/gim;
 const IssueRE = /(#\d+)/gm;
 const ChangedFileRegex = /(A|M|D|R\d*|C\d*)\t([^\t\n]*)\t?(.*)?/gm;
 const RevertHashRE = /This reverts commit (?<hash>[\da-f]{40})./gm;
@@ -402,7 +421,7 @@ function parseGitCommit(commit, isVersionPlanCommit = false) {
             description: commit.message,
             type: '',
             scope: '',
-            references: extractReferencesFromCommitMessage(commit.message, commit.shortHash),
+            references: extractReferencesFromCommit(commit),
             // The commit message is not the source of truth for a breaking (major) change in version plans, so the value is not relevant
             // TODO(v22): Make the current GitCommit interface more clearly tied to conventional commits
             isBreaking: false,
@@ -420,9 +439,9 @@ function parseGitCommit(commit, isVersionPlanCommit = false) {
     const scope = parsedMessage.scope;
     const isBreaking = parsedMessage.breaking || commit.body.includes('BREAKING CHANGE:');
     let description = parsedMessage.description;
-    // Extract references from message
-    const references = extractReferencesFromCommitMessage(description, commit.shortHash);
-    // Remove references and normalize
+    // Extract issue and PR references from the commit
+    const references = extractReferencesFromCommit(commit);
+    // Remove GitHub style references from description (NOTE: GitLab style references only seem to appear in the body, so we don't need to remove them here)
     description = description.replace(PullRequestRE, '').trim();
     let type = parsedMessage.type;
     // Extract any reverted hashes, if applicable

package/src/command-line/release/utils/remote-release-clients/github.d.ts

@@ -0,0 +1,57 @@
+import type { PostGitTask } from '../../changelog';
+import { type ResolvedCreateRemoteReleaseProvider } from '../../config/config';
+import { Reference } from '../git';
+import { ReleaseVersion } from '../shared';
+import { RemoteReleaseClient, RemoteReleaseOptions, RemoteReleaseResult, RemoteRepoData } from './remote-release-client';
+export interface GithubRepoData extends RemoteRepoData {
+}
+export interface GithubRemoteRelease {
+    id?: string;
+    body: string;
+    tag_name: string;
+    target_commitish?: string;
+    name?: string;
+    draft?: boolean;
+    prerelease?: boolean;
+    make_latest?: 'legacy' | boolean;
+}
+export declare const defaultCreateReleaseProvider: ResolvedCreateRemoteReleaseProvider;
+export declare class GithubRemoteReleaseClient extends RemoteReleaseClient<GithubRemoteRelease> {
+    remoteReleaseProviderName: string;
+    /**
+     * Get GitHub repository data from git remote
+     */
+    static resolveRepoData(createReleaseConfig: false | ResolvedCreateRemoteReleaseProvider, remoteName?: string): GithubRepoData | null;
+    /**
+     * Resolve a GitHub token from environment variables or gh CLI
+     */
+    static resolveTokenData(hostname: string): Promise<{
+        token: string;
+        headerName: string;
+    } | null>;
+    createPostGitTask(releaseVersion: ReleaseVersion, changelogContents: string, dryRun: boolean): PostGitTask;
+    applyUsernameToAuthors(authors: Map<string, {
+        email: Set<string>;
+        username?: string;
+    }>): Promise<void>;
+    /**
+     * Get a release by tag
+     */
+    protected getReleaseByTag(tag: string): Promise<GithubRemoteRelease>;
+    /**
+     * Create a new release
+     */
+    protected createRelease(remoteRelease: GithubRemoteRelease): Promise<any>;
+    protected updateRelease(id: string, remoteRelease: GithubRemoteRelease): Promise<any>;
+    protected getManualRemoteReleaseURL(remoteReleaseOptions: RemoteReleaseOptions): string;
+    protected handleAuthError(): void;
+    protected logReleaseAction(existingRelease: GithubRemoteRelease | undefined, gitTag: string, dryRun: boolean): void;
+    protected handleError(error: any, result: RemoteReleaseResult): Promise<void>;
+    private promptForContinueInGitHub;
+    /**
+     * Format references for the release (e.g., PRs, issues)
+     */
+    formatReferences(references: Reference[]): string;
+    protected syncRelease(remoteReleaseOptions: RemoteReleaseOptions, existingRelease?: GithubRemoteRelease): Promise<RemoteReleaseResult>;
+    private getRequiredRemoteRepoData;
+}

package/src/command-line/release/utils/remote-release-clients/github.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GithubRemoteReleaseClient = exports.defaultCreateReleaseProvider = void 0;
+const chalk = require("chalk");
+const enquirer_1 = require("enquirer");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const output_1 = require("../../../../utils/output");
+const path_1 = require("../../../../utils/path");
+const remote_release_client_1 = require("./remote-release-client");
+// axios types and values don't seem to match
+const _axios = require("axios");
+const axios = _axios;
+exports.defaultCreateReleaseProvider = {
+    provider: 'github',
+    hostname: 'github.com',
+    apiBaseUrl: 'https://api.github.com',
+};
+class GithubRemoteReleaseClient extends remote_release_client_1.RemoteReleaseClient {
+    constructor() {
+        super(...arguments);
+        this.remoteReleaseProviderName = 'GitHub';
+    }
+    /**
+     * Get GitHub repository data from git remote
+     */
+    static resolveRepoData(createReleaseConfig, remoteName = 'origin') {
+        try {
+            const remoteUrl = (0, node_child_process_1.execSync)(`git remote get-url ${remoteName}`, {
+                encoding: 'utf8',
+                stdio: 'pipe',
+            }).trim();
+            // Use the default provider if custom one is not specified or releases are disabled
+            let hostname = exports.defaultCreateReleaseProvider.hostname;
+            let apiBaseUrl = exports.defaultCreateReleaseProvider.apiBaseUrl;
+            if (createReleaseConfig !== false &&
+                typeof createReleaseConfig !== 'string') {
+                hostname = createReleaseConfig.hostname;
+                apiBaseUrl = createReleaseConfig.apiBaseUrl;
+            }
+            // Extract the 'user/repo' part from the URL
+            const escapedHostname = hostname.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const regexString = `${escapedHostname}[/:]([\\w.-]+/[\\w.-]+)(\\.git)?`;
+            const regex = new RegExp(regexString);
+            const match = remoteUrl.match(regex);
+            if (match && match[1]) {
+                return {
+                    hostname,
+                    apiBaseUrl,
+                    // Ensure any trailing .git is stripped
+                    slug: match[1].replace(/\.git$/, ''),
+                };
+            }
+            else {
+                throw new Error(`Could not extract "user/repo" data from the resolved remote URL: ${remoteUrl}`);
+            }
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Resolve a GitHub token from environment variables or gh CLI
+     */
+    static async resolveTokenData(hostname) {
+        // Try and resolve from the environment
+        const tokenFromEnv = process.env.GITHUB_TOKEN || process.env.GH_TOKEN;
+        if (tokenFromEnv) {
+            return { token: tokenFromEnv, headerName: 'Authorization' };
+        }
+        // Try and resolve from gh CLI installation
+        const ghCLIPath = (0, path_1.joinPathFragments)(process.env.XDG_CONFIG_HOME || (0, path_1.joinPathFragments)((0, node_os_1.homedir)(), '.config'), 'gh', 'hosts.yml');
+        if ((0, node_fs_1.existsSync)(ghCLIPath)) {
+            const yamlContents = await node_fs_1.promises.readFile(ghCLIPath, 'utf8');
+            const { load } = require('@zkochan/js-yaml');
+            const ghCLIConfig = load(yamlContents);
+            if (ghCLIConfig[hostname]) {
+                // Web based session (the token is already embedded in the config)
+                if (ghCLIConfig[hostname].oauth_token) {
+                    return ghCLIConfig[hostname].oauth_token;
+                }
+                // SSH based session (we need to dynamically resolve a token using the CLI)
+                if (ghCLIConfig[hostname].user &&
+                    ghCLIConfig[hostname].git_protocol === 'ssh') {
+                    const token = (0, node_child_process_1.execSync)(`gh auth token`, {
+                        encoding: 'utf8',
+                        stdio: 'pipe',
+                        windowsHide: false,
+                    }).trim();
+                    return { token, headerName: 'Authorization' };
+                }
+            }
+        }
+        if (hostname !== 'github.com') {
+            console.log(`Warning: It was not possible to automatically resolve a GitHub token from your environment for hostname ${hostname}. If you set the GITHUB_TOKEN or GH_TOKEN environment variable, that will be used for GitHub API requests.`);
+        }
+        return null;
+    }
+    createPostGitTask(releaseVersion, changelogContents, dryRun) {
+        return async (latestCommit) => {
+            output_1.output.logSingleLine(`Creating GitHub Release`);
+            await this.createOrUpdateRelease(releaseVersion, changelogContents, latestCommit, { dryRun });
+        };
+    }
+    async applyUsernameToAuthors(authors) {
+        await Promise.all([...authors.keys()].map(async (authorName) => {
+            const meta = authors.get(authorName);
+            for (const email of meta.email) {
+                if (email.endsWith('@users.noreply.github.com')) {
+                    const match = email.match(/^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
+                    if (match && match[2]) {
+                        meta.username = match[2];
+                        break;
+                    }
+                }
+                const { data } = await axios
+                    .get(`https://ungh.cc/users/find/${email}`)
+                    .catch(() => ({ data: { user: null } }));
+                if (data?.user) {
+                    meta.username = data.user.username;
+                    break;
+                }
+            }
+        }));
+    }
+    /**
+     * Get a release by tag
+     */
+    async getReleaseByTag(tag) {
+        const githubRepoData = this.getRequiredRemoteRepoData();
+        return await this.makeRequest(`/repos/${githubRepoData.slug}/releases/tags/${tag}`);
+    }
+    /**
+     * Create a new release
+     */
+    async createRelease(remoteRelease) {
+        const githubRepoData = this.getRequiredRemoteRepoData();
+        return await this.makeRequest(`/repos/${githubRepoData.slug}/releases`, {
+            method: 'POST',
+            data: remoteRelease,
+        });
+    }
+    async updateRelease(id, remoteRelease) {
+        const githubRepoData = this.getRequiredRemoteRepoData();
+        return await this.makeRequest(`/repos/${githubRepoData.slug}/releases/${id}`, {
+            method: 'PATCH',
+            data: remoteRelease,
+        });
+    }
+    getManualRemoteReleaseURL(remoteReleaseOptions) {
+        const githubRepoData = this.getRequiredRemoteRepoData();
+        // Parameters taken from https://github.com/isaacs/github/issues/1410#issuecomment-442240267
+        let url = `https://${githubRepoData.hostname}/${githubRepoData.slug}/releases/new?tag=${remoteReleaseOptions.version}&title=${remoteReleaseOptions.version}&body=${encodeURIComponent(remoteReleaseOptions.body)}&target=${remoteReleaseOptions.commit}`;
+        if (remoteReleaseOptions.prerelease) {
+            url += '&prerelease=true';
+        }
+        return url;
+    }
+    handleAuthError() {
+        output_1.output.error({
+            title: `Unable to resolve data via the GitHub API. You can use any of the following options to resolve this:`,
+            bodyLines: [
+                '- Set the `GITHUB_TOKEN` or `GH_TOKEN` environment variable to a valid GitHub token with `repo` scope',
+                '- Have an active session via the official gh CLI tool (https://cli.github.com) in your current terminal',
+            ],
+        });
+    }
+    logReleaseAction(existingRelease, gitTag, dryRun) {
+        const githubRepoData = this.getRequiredRemoteRepoData();
+        const logTitle = `https://${githubRepoData.hostname}/${githubRepoData.slug}/releases/tag/${gitTag}`;
+        if (existingRelease) {
+            console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+        }
+        else {
+            console.error(`${chalk.green('CREATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+        }
+    }
+    async handleError(error, result) {
+        if (error) {
+            process.exitCode = 1;
+            if (error.response?.data) {
+                // There's a nicely formatted error from GitHub we can display to the user
+                output_1.output.error({
+                    title: `A GitHub API Error occurred when creating/updating the release`,
+                    bodyLines: [
+                        `GitHub Error: ${JSON.stringify(error.response.data)}`,
+                        `---`,
+                        `Request Data:`,
+                        `Repo: ${this.getRemoteRepoData()?.slug}`,
+                        `Token Header Data: ${this.tokenHeader}`,
+                        `Body: ${JSON.stringify(result.requestData)}`,
+                    ],
+                });
+            }
+            else {
+                console.log(error);
+                console.error(`An unknown error occurred while trying to create a release on GitHub, please report this on https://github.com/nrwl/nx (NOTE: make sure to redact your GitHub token from the error message!)`);
+            }
+        }
+        const shouldContinueInGitHub = await this.promptForContinueInGitHub();
+        if (!shouldContinueInGitHub) {
+            return;
+        }
+        const open = require('open');
+        await open(result.url)
+            .then(() => {
+            console.info(`\nFollow up in the browser to manually create the release:\n\n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                `\n`);
+        })
+            .catch(() => {
+            console.info(`Open this link to manually create a release: \n` +
+                chalk.underline(chalk.cyan(result.url)) +
+                '\n');
+        });
+    }
+    async promptForContinueInGitHub() {
+        try {
+            const reply = await (0, enquirer_1.prompt)([
+                {
+                    name: 'open',
+                    message: 'Do you want to finish creating the release manually in your browser?',
+                    type: 'autocomplete',
+                    choices: [
+                        {
+                            name: 'Yes',
+                            hint: 'It will pre-populate the form for you',
+                        },
+                        {
+                            name: 'No',
+                        },
+                    ],
+                    initial: 0,
+                },
+            ]);
+            return reply.open === 'Yes';
+        }
+        catch {
+            // Ensure the cursor is always restored before exiting
+            process.stdout.write('\u001b[?25h');
+            // Handle the case where the user exits the prompt with ctrl+c
+            process.exit(1);
+        }
+    }
+    /**
+     * Format references for the release (e.g., PRs, issues)
+     */
+    formatReferences(references) {
+        const githubRepoData = this.getRequiredRemoteRepoData();
+        const providerToRefSpec = {
+            github: { 'pull-request': 'pull', hash: 'commit', issue: 'issues' },
+        };
+        const refSpec = providerToRefSpec.github;
+        const formatSingleReference = (ref) => {
+            return `[${ref.value}](https://${githubRepoData.hostname}/${githubRepoData.slug}/${refSpec[ref.type]}/${ref.value.replace(/^#/, '')})`;
+        };
+        const pr = references.filter((ref) => ref.type === 'pull-request');
+        const issue = references.filter((ref) => ref.type === 'issue');
+        if (pr.length > 0 || issue.length > 0) {
+            return (' (' +
+                [...pr, ...issue].map((ref) => formatSingleReference(ref)).join(', ') +
+                ')');
+        }
+        if (references.length > 0) {
+            return ' (' + formatSingleReference(references[0]) + ')';
+        }
+        return '';
+    }
+    async syncRelease(remoteReleaseOptions, existingRelease) {
+        const githubReleaseData = {
+            tag_name: remoteReleaseOptions.version,
+            name: remoteReleaseOptions.version,
+            body: remoteReleaseOptions.body,
+            prerelease: remoteReleaseOptions.prerelease,
+            // legacy specifies that the latest release should be determined based on the release creation date and higher semantic version.
+            make_latest: 'legacy',
+        };
+        try {
+            const newGhRelease = await (existingRelease
+                ? this.updateRelease(existingRelease.id, githubReleaseData)
+                : this.createRelease({
+                    ...githubReleaseData,
+                    target_commitish: remoteReleaseOptions.commit,
+                }));
+            return {
+                status: existingRelease ? 'updated' : 'created',
+                id: newGhRelease.id,
+                url: newGhRelease.html_url,
+            };
+        }
+        catch (error) {
+            return {
+                status: 'manual',
+                error,
+                url: this.getManualRemoteReleaseURL(remoteReleaseOptions),
+                requestData: githubReleaseData,
+            };
+        }
+    }
+    getRequiredRemoteRepoData() {
+        const githubRepoData = this.getRemoteRepoData();
+        if (!githubRepoData) {
+            throw new Error(`No remote repo data could be resolved for the current workspace`);
+        }
+        return githubRepoData;
+    }
+}
+exports.GithubRemoteReleaseClient = GithubRemoteReleaseClient;