nx 18.0.4 → 18.0.5

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

@@ -11,6 +11,7 @@ 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 github_1 = require("./utils/github");
 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");
@@ -51,13 +52,14 @@ async function release(args) {
         gitCommit: false,
         gitTag: false,
     });
-    await (0, changelog_1.releaseChangelog)({
+    const changelogResult = await (0, changelog_1.releaseChangelog)({
         ...args,
         versionData: versionResult.projectsVersionData,
         version: versionResult.workspaceVersion,
         stageChanges: shouldStage,
         gitCommit: false,
         gitTag: false,
+        createRelease: false,
     });
     const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
     if (filterError) {
@@ -90,8 +92,59 @@ async function release(args) {
             });
         }
     }
-    let shouldPublish = !!args.yes && !args.skipPublish;
-    const shouldPromptPublishing = !args.yes && !args.skipPublish && !args.dryRun;
+    const shouldCreateWorkspaceRelease = (0, changelog_1.shouldCreateGitHubRelease)(nxReleaseConfig.changelog.workspaceChangelog);
+    let hasPushedChanges = false;
+    let latestCommit;
+    if (shouldCreateWorkspaceRelease && changelogResult.workspaceChangelog) {
+        devkit_exports_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;
+        devkit_exports_1.output.logSingleLine(`Creating GitHub Release`);
+        latestCommit = await (0, git_1.getCommitHash)('HEAD');
+        await (0, github_1.createOrUpdateGithubRelease)(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) {
+                    devkit_exports_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;
+                }
+                devkit_exports_1.output.logSingleLine(`Creating GitHub Release`);
+                if (!latestCommit) {
+                    latestCommit = await (0, git_1.getCommitHash)('HEAD');
+                }
+                await (0, github_1.createOrUpdateGithubRelease)(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();
     }

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

@@ -48,7 +48,11 @@ export declare function gitTag({ tag, message, additionalArgs, dryRun, verbose,
     verbose?: boolean;
     logFn?: (message: string) => void;
 }): Promise<string>;
-export declare function gitPush(gitRemote?: string): Promise<void>;
+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 parseGitCommit(commit: RawGitCommit): GitCommit | null;
 export declare function getCommitHash(ref: string): Promise<string>;

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

@@ -155,17 +155,27 @@ async function gitTag({ tag, message, additionalArgs, dryRun, verbose, logFn, })
     }
 }
 exports.gitTag = gitTag;
-async function gitPush(gitRemote) {
+async function gitPush({ gitRemote, dryRun, verbose, }) {
+    const commandArgs = [
+        'push',
+        // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
+        '--follow-tags',
+        '--no-verify',
+        '--atomic',
+        // Set custom git remote if provided
+        ...(gitRemote ? [gitRemote] : []),
+    ];
+    if (verbose) {
+        console.log(dryRun
+            ? `Would push the current branch to the remote with the following command, but --dry-run was set:`
+            : `Pushing the current branch to the remote with the following command:`);
+        console.log(`git ${commandArgs.join(' ')}`);
+    }
+    if (dryRun) {
+        return;
+    }
     try {
-        await (0, exec_command_1.execCommand)('git', [
-            'push',
-            // NOTE: It's important we use --follow-tags, and not --tags, so that we are precise about what we are pushing
-            '--follow-tags',
-            '--no-verify',
-            '--atomic',
-            // Set custom git remote if provided
-            ...(gitRemote ? [gitRemote] : []),
-        ]);
+        await (0, exec_command_1.execCommand)('git', commandArgs);
     }
     catch (err) {
         throw new Error(`Unexpected git push error: ${err}`);
@@ -252,7 +262,12 @@ async function getCommitHash(ref) {
 exports.getCommitHash = getCommitHash;
 async function getFirstGitCommit() {
     try {
-        return (await (0, exec_command_1.execCommand)('git', ['rev-list', '--max-parents=0', 'HEAD'])).trim();
+        return (await (0, exec_command_1.execCommand)('git', [
+            'rev-list',
+            '--max-parents=0',
+            'HEAD',
+            '--first-parent',
+        ])).trim();
     }
     catch (e) {
         throw new Error(`Unable to find first commit in git history`);

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

@@ -1,4 +1,5 @@
 import { Reference } from './git';
+import { ReleaseVersion } from './shared';
 export type RepoSlug = `${string}/${string}`;
 export interface GithubRequestConfig {
     repo: string;
@@ -14,14 +15,9 @@ export interface GithubRelease {
     prerelease?: boolean;
 }
 export declare function getGitHubRepoSlug(remoteName?: string): RepoSlug;
-interface GithubReleaseOptions {
-    version: string;
-    body: string;
-    prerelease: boolean;
-    commit: string;
-}
-export declare function createOrUpdateGithubRelease(githubRequestConfig: GithubRequestConfig, release: GithubReleaseOptions, existingGithubReleaseForVersion?: GithubRelease): Promise<void>;
+export declare function createOrUpdateGithubRelease(releaseVersion: ReleaseVersion, changelogContents: string, latestCommit: string, { dryRun }: {
+    dryRun: boolean;
+}): Promise<void>;
 export declare function resolveGithubToken(): Promise<string | null>;
 export declare function getGithubReleaseByTag(config: GithubRequestConfig, tag: string): Promise<GithubRelease>;
 export declare function formatReferences(references: Reference[], repoSlug: RepoSlug): string;
-export {};

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

@@ -8,6 +8,8 @@ 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 print_changes_1 = require("./print-changes");
+const shared_1 = require("./shared");
 // axios types and values don't seem to match
 const _axios = require("axios");
 const axios = _axios;
@@ -32,7 +34,65 @@ function getGitHubRepoSlug(remoteName = 'origin') {
     }
 }
 exports.getGitHubRepoSlug = getGitHubRepoSlug;
-async function createOrUpdateGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion) {
+async function createOrUpdateGithubRelease(releaseVersion, changelogContents, latestCommit, { dryRun }) {
+    const githubRepoSlug = getGitHubRepoSlug();
+    if (!githubRepoSlug) {
+        output_1.output.error({
+            title: `Unable to create a GitHub release because the GitHub repo slug could not be determined.`,
+            bodyLines: [
+                `Please ensure you have a valid GitHub remote configured. You can run \`git remote -v\` to list your current remotes.`,
+            ],
+        });
+        process.exit(1);
+    }
+    const token = await resolveGithubToken();
+    const githubRequestConfig = {
+        repo: githubRepoSlug,
+        token,
+    };
+    let existingGithubReleaseForVersion;
+    try {
+        existingGithubReleaseForVersion = await getGithubReleaseByTag(githubRequestConfig, releaseVersion.gitTag);
+    }
+    catch (err) {
+        if (err.response?.status === 401) {
+            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',
+                ],
+            });
+            process.exit(1);
+        }
+        if (err.response?.status === 404) {
+            // No existing release found, this is fine
+        }
+        else {
+            // Rethrow unknown errors for now
+            throw err;
+        }
+    }
+    const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
+    if (existingGithubReleaseForVersion) {
+        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]') : ''}`);
+    }
+    console.log('');
+    (0, print_changes_1.printDiff)(existingGithubReleaseForVersion ? existingGithubReleaseForVersion.body : '', changelogContents, 3, shared_1.noDiffInChangelogMessage);
+    if (!dryRun) {
+        await createOrUpdateGithubReleaseInternal(githubRequestConfig, {
+            version: releaseVersion.gitTag,
+            prerelease: releaseVersion.isPrerelease,
+            body: changelogContents,
+            commit: latestCommit,
+        }, existingGithubReleaseForVersion);
+    }
+}
+exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
+async function createOrUpdateGithubReleaseInternal(githubRequestConfig, release, existingGithubReleaseForVersion) {
     const result = await syncGithubRelease(githubRequestConfig, release, existingGithubReleaseForVersion);
     /**
      * If something went wrong POSTing to Github we can still pre-populate the web form on github.com
@@ -98,7 +158,6 @@ async function createOrUpdateGithubRelease(githubRequestConfig, release, existin
         });
     }
 }
-exports.createOrUpdateGithubRelease = createOrUpdateGithubRelease;
 async function promptForContinueInGitHub() {
     try {
         const reply = await (0, enquirer_1.prompt)([

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

@@ -2,6 +2,7 @@ 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: {

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

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCommitsRelevantToProjects = exports.handleDuplicateGitTags = exports.createGitTagValues = exports.createCommitMessageValues = exports.commitChanges = exports.ReleaseVersion = void 0;
+exports.getCommitsRelevantToProjects = exports.handleDuplicateGitTags = exports.createGitTagValues = exports.createCommitMessageValues = exports.commitChanges = exports.ReleaseVersion = exports.noDiffInChangelogMessage = void 0;
+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;

package/src/core/graph/3rdpartylicenses.txt

@@ -704,57 +704,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
 
-regenerator-runtime
-MIT
-MIT License
-
-Copyright (c) 2014-present, Facebook, Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
-tabbable
-MIT
-The MIT License (MIT)
-
-Copyright (c) 2015 David Clark
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-
-
 toggle-selection
 MIT