nx 18.1.0-canary.20240213-7d2cb37 → 18.1.0-canary.20240214-b625a79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.1.0-canary.20240213-7d2cb37",
+  "version": "18.1.0-canary.20240214-b625a79",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -66,7 +66,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "18.1.0-canary.20240213-7d2cb37"
+    "@nrwl/tao": "18.1.0-canary.20240214-b625a79"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-darwin-arm64": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-linux-x64-gnu": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-linux-x64-musl": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-win32-x64-msvc": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-linux-arm64-gnu": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-linux-arm64-musl": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-linux-arm-gnueabihf": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-win32-arm64-msvc": "18.1.0-canary.20240213-7d2cb37",
-    "@nx/nx-freebsd-x64": "18.1.0-canary.20240213-7d2cb37"
+    "@nx/nx-darwin-x64": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-darwin-arm64": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-linux-x64-gnu": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-linux-x64-musl": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-win32-x64-msvc": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-linux-arm64-gnu": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-linux-arm64-musl": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-linux-arm-gnueabihf": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-win32-arm64-msvc": "18.1.0-canary.20240214-b625a79",
+    "@nx/nx-freebsd-x64": "18.1.0-canary.20240214-b625a79"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

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

@@ -862,7 +862,17 @@ function runInstall() {
 async function executeMigrations(root, migrations, isVerbose, shouldCreateCommits, commitPrefix) {
     const depsBeforeMigrations = getStringifiedPackageJsonDeps(root);
     const migrationsWithNoChanges = [];
-    for (const m of migrations) {
+    const sortedMigrations = migrations.sort((a, b) => {
+        // special case for the split configuration migration to run first
+        if (a.name === '15-7-0-split-configuration-into-project-json-files') {
+            return -1;
+        }
+        if (b.name === '15-7-0-split-configuration-into-project-json-files') {
+            return 1;
+        }
+        return (0, semver_1.lt)(a.version, b.version) ? -1 : 1;
+    });
+    for (const m of sortedMigrations) {
         try {
             const { collection, collectionPath } = readMigrationCollection(m.package, root);
             if (!isAngularMigration(collection, collectionPath, m.name)) {

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

@@ -1,8 +1,23 @@
+import { NxReleaseChangelogConfiguration } from '../../config/nx-json';
 import { ChangelogOptions } from './command-object';
+import { ReleaseVersion } from './utils/shared';
+export interface NxReleaseChangelogResult {
+    workspaceChangelog?: {
+        releaseVersion: ReleaseVersion;
+        contents: string;
+    };
+    projectChangelogs?: {
+        [projectName: string]: {
+            releaseVersion: ReleaseVersion;
+            contents: string;
+        };
+    };
+}
 export declare const releaseChangelogCLIHandler: (args: ChangelogOptions) => Promise<any>;
 /**
  * NOTE: This function is also exported for programmatic usage and forms part of the public API
  * of Nx. We intentionally do not wrap the implementation with handleErrors because users need
  * to have control over their own error handling when using the API.
  */
-export declare function releaseChangelog(args: ChangelogOptions): Promise<number>;
+export declare function releaseChangelog(args: ChangelogOptions): Promise<NxReleaseChangelogResult>;
+export declare function shouldCreateGitHubRelease(changelogConfig: NxReleaseChangelogConfiguration | false | undefined, createReleaseArg?: ChangelogOptions['createRelease'] | undefined): boolean;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.releaseChangelog = exports.releaseChangelogCLIHandler = void 0;
+exports.shouldCreateGitHubRelease = exports.releaseChangelog = exports.releaseChangelogCLIHandler = void 0;
 const chalk = require("chalk");
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
@@ -74,7 +74,7 @@ async function releaseChangelog(args) {
                 `To explicitly enable changelog generation, configure "release.changelog.workspaceChangelog" or "release.changelog.projectChangelogs" in nx.json.`,
             ],
         });
-        return 0;
+        return {};
     }
     const useAutomaticFromRef = nxReleaseConfig.changelog?.automaticFromRef || args.firstRelease;
     /**
@@ -128,7 +128,26 @@ async function releaseChangelog(args) {
     // Make sure that the fromRef is actually resolvable
     const workspaceChangelogFromSHA = await (0, git_1.getCommitHash)(workspaceChangelogFromRef);
     const workspaceChangelogCommits = await getCommits(workspaceChangelogFromSHA, toSHA);
-    await generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, workspaceChangelogCommits, postGitTasks);
+    const workspaceChangelog = await generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, workspaceChangelogCommits);
+    if (workspaceChangelog &&
+        shouldCreateGitHubRelease(nxReleaseConfig.changelog.workspaceChangelog, args.createRelease)) {
+        let hasPushed = false;
+        postGitTasks.push(async (latestCommit) => {
+            if (!hasPushed) {
+                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)({
+                    gitRemote: args.gitRemote,
+                    dryRun: args.dryRun,
+                    verbose: args.verbose,
+                });
+                hasPushed = true;
+            }
+            output_1.output.logSingleLine(`Creating GitHub Release`);
+            await (0, github_1.createOrUpdateGithubRelease)(workspaceChangelog.releaseVersion, workspaceChangelog.contents, latestCommit, { dryRun: args.dryRun });
+        });
+    }
+    const allProjectChangelogs = {};
     for (const releaseGroup of releaseGroups) {
         const config = releaseGroup.changelog;
         // The entire feature is disabled at the release group level, exit early
@@ -164,7 +183,28 @@ async function releaseChangelog(args) {
                 if (!commits) {
                     commits = await getCommits(fromRef, toSHA);
                 }
-                await generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, postGitTasks, releaseGroup, [project]);
+                const projectChangelogs = await generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, postGitTasks, releaseGroup, [project]);
+                let hasPushed = false;
+                for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
+                    if (projectChangelogs &&
+                        shouldCreateGitHubRelease(releaseGroup.changelog, args.createRelease)) {
+                        postGitTasks.push(async (latestCommit) => {
+                            if (!hasPushed) {
+                                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)({
+                                    gitRemote: args.gitRemote,
+                                    dryRun: args.dryRun,
+                                    verbose: args.verbose,
+                                });
+                                hasPushed = true;
+                            }
+                            output_1.output.logSingleLine(`Creating GitHub Release`);
+                            await (0, github_1.createOrUpdateGithubRelease)(projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
+                        });
+                    }
+                    allProjectChangelogs[projectName] = projectChangelog;
+                }
             }
         }
         else {
@@ -176,10 +216,35 @@ async function releaseChangelog(args) {
             // Make sure that the fromRef is actually resolvable
             const fromSHA = await (0, git_1.getCommitHash)(fromRef);
             const commits = await getCommits(fromSHA, toSHA);
-            await generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, postGitTasks, releaseGroup, projectNodes);
+            const projectChangelogs = await generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, postGitTasks, releaseGroup, projectNodes);
+            let hasPushed = false;
+            for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
+                if (projectChangelogs &&
+                    shouldCreateGitHubRelease(releaseGroup.changelog, args.createRelease)) {
+                    postGitTasks.push(async (latestCommit) => {
+                        if (!hasPushed) {
+                            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)({
+                                gitRemote: args.gitRemote,
+                                dryRun: args.dryRun,
+                                verbose: args.verbose,
+                            });
+                            hasPushed = true;
+                        }
+                        output_1.output.logSingleLine(`Creating GitHub Release`);
+                        await (0, github_1.createOrUpdateGithubRelease)(projectChangelog.releaseVersion, projectChangelog.contents, latestCommit, { dryRun: args.dryRun });
+                    });
+                }
+                allProjectChangelogs[projectName] = projectChangelog;
+            }
         }
     }
-    return await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
+    await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
+    return {
+        workspaceChangelog,
+        projectChangelogs: allProjectChangelogs,
+    };
 }
 exports.releaseChangelog = releaseChangelog;
 function resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects) {
@@ -237,7 +302,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
                 `No changes were detected for any changelog files, so no changelog entries will be generated.`,
             ],
         });
-        return 0;
+        return;
     }
     // Generate a new commit for the changes, if configured to do so
     if (args.gitCommit ?? nxReleaseConfig.changelog.git.commit) {
@@ -271,7 +336,7 @@ async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTa
     for (const postGitTask of postGitTasks) {
         await postGitTask(latestCommit);
     }
-    return 0;
+    return;
 }
 function resolveChangelogRenderer(changelogRendererPath) {
     // Try and load the provided (or default) changelog renderer
@@ -292,7 +357,7 @@ function resolveChangelogRenderer(changelogRendererPath) {
     }
     return changelogRenderer;
 }
-async function generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, commits, postGitTasks) {
+async function generateChangelogForWorkspace(tree, args, projectGraph, nxReleaseConfig, workspaceChangelogVersion, commits) {
     const config = nxReleaseConfig.changelog.workspaceChangelog;
     // The entire feature is disabled at the workspace level, exit early
     if (config === false) {
@@ -344,21 +409,12 @@ async function generateChangelogForWorkspace(tree, args, projectGraph, nxRelease
         version: workspaceChangelogVersion,
         releaseTagPattern: nxReleaseConfig.releaseTagPattern,
     });
-    // We are either creating/previewing a changelog file, a GitHub release, or both
-    let logTitle = dryRun ? 'Previewing a' : 'Generating a';
-    switch (true) {
-        case interpolatedTreePath && config.createRelease === 'github':
-            logTitle += ` GitHub release and an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-            break;
-        case !!interpolatedTreePath:
-            logTitle += `n entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-            break;
-        case config.createRelease === 'github':
-            logTitle += ` GitHub release for ${chalk.white(releaseVersion.gitTag)}`;
-    }
-    output_1.output.log({
-        title: logTitle,
-    });
+    if (interpolatedTreePath) {
+        const prefix = dryRun ? 'Previewing' : 'Generating';
+        output_1.output.log({
+            title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`,
+        });
+    }
     const githubRepoSlug = (0, github_1.getGitHubRepoSlug)(gitRemote);
     let contents = await changelogRenderer({
         projectGraph,
@@ -382,12 +438,6 @@ async function generateChangelogForWorkspace(tree, args, projectGraph, nxRelease
         await (0, launch_editor_1.launchEditor)(changelogPath);
         contents = (0, node_fs_1.readFileSync)(changelogPath, 'utf-8');
     }
-    /**
-     * The exact logic we use for printing the summary/diff to the user is dependent upon whether they are creating
-     * a changelog file, a GitHub release, or both.
-     */
-    let printSummary = () => { };
-    const 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?`);
     if (interpolatedTreePath) {
         let rootChangelogContents = tree.exists(interpolatedTreePath)
             ? tree.read(interpolatedTreePath).toString()
@@ -409,79 +459,12 @@ async function generateChangelogForWorkspace(tree, args, projectGraph, nxRelease
             rootChangelogContents = contents;
         }
         tree.write(interpolatedTreePath, rootChangelogContents);
-        printSummary = () => (0, print_changes_1.printAndFlushChanges)(tree, !!dryRun, 3, false, noDiffInChangelogMessage);
-    }
-    if (config.createRelease === 'github') {
-        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 (0, github_1.resolveGithubToken)();
-        const githubRequestConfig = {
-            repo: githubRepoSlug,
-            token,
-        };
-        let existingGithubReleaseForVersion;
-        try {
-            existingGithubReleaseForVersion = await (0, github_1.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;
-            }
-        }
-        let existingPrintSummaryFn = printSummary;
-        printSummary = () => {
-            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]') : ''}`);
-            }
-            // Only print the diff here if we are not already going to be printing changes from the Tree
-            if (!interpolatedTreePath) {
-                console.log('');
-                (0, print_changes_1.printDiff)(existingGithubReleaseForVersion
-                    ? existingGithubReleaseForVersion.body
-                    : '', contents, 3, noDiffInChangelogMessage);
-            }
-            existingPrintSummaryFn();
-        };
-        // Only schedule the actual GitHub update when not in dry-run mode
-        if (!dryRun) {
-            postGitTasks.push(async (latestCommit) => {
-                // Before we can create/update the release we need to ensure the commit exists on the remote
-                await (0, git_1.gitPush)();
-                await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
-                    version: releaseVersion.gitTag,
-                    prerelease: releaseVersion.isPrerelease,
-                    body: contents,
-                    commit: latestCommit,
-                }, existingGithubReleaseForVersion);
-            });
-        }
+        (0, print_changes_1.printAndFlushChanges)(tree, !!dryRun, 3, false, shared_1.noDiffInChangelogMessage);
     }
-    printSummary();
+    return {
+        releaseVersion,
+        contents,
+    };
 }
 async function generateChangelogForProjects(tree, args, projectGraph, commits, projectsVersionData, postGitTasks, releaseGroup, projects) {
     const config = releaseGroup.changelog;
@@ -494,6 +477,7 @@ async function generateChangelogForProjects(tree, args, projectGraph, commits, p
     const dryRun = !!args.dryRun;
     const gitRemote = args.gitRemote;
     const changelogRenderer = resolveChangelogRenderer(config.renderer);
+    const projectChangelogs = {};
     for (const project of projects) {
         let interpolatedTreePath = config.file || '';
         if (interpolatedTreePath) {
@@ -515,21 +499,12 @@ async function generateChangelogForProjects(tree, args, projectGraph, commits, p
             releaseTagPattern: releaseGroup.releaseTagPattern,
             projectName: project.name,
         });
-        // We are either creating/previewing a changelog file, a GitHub release, or both
-        let logTitle = dryRun ? 'Previewing a' : 'Generating a';
-        switch (true) {
-            case interpolatedTreePath && config.createRelease === 'github':
-                logTitle += ` GitHub release and an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-                break;
-            case !!interpolatedTreePath:
-                logTitle += `n entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`;
-                break;
-            case config.createRelease === 'github':
-                logTitle += ` GitHub release for ${chalk.white(releaseVersion.gitTag)}`;
+        if (interpolatedTreePath) {
+            const prefix = dryRun ? 'Previewing' : 'Generating';
+            output_1.output.log({
+                title: `${prefix} an entry in ${interpolatedTreePath} for ${chalk.white(releaseVersion.gitTag)}`,
+            });
         }
-        output_1.output.log({
-            title: logTitle,
-        });
         const githubRepoSlug = config.createRelease === 'github'
             ? (0, github_1.getGitHubRepoSlug)(gitRemote)
             : undefined;
@@ -561,12 +536,6 @@ async function generateChangelogForProjects(tree, args, projectGraph, commits, p
             await (0, launch_editor_1.launchEditor)(changelogPath);
             contents = (0, node_fs_1.readFileSync)(changelogPath, 'utf-8');
         }
-        /**
-         * The exact logic we use for printing the summary/diff to the user is dependent upon whether they are creating
-         * a changelog file, a GitHub release, or both.
-         */
-        let printSummary = () => { };
-        const 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?`);
         if (interpolatedTreePath) {
             let changelogContents = tree.exists(interpolatedTreePath)
                 ? tree.read(interpolatedTreePath).toString()
@@ -588,82 +557,16 @@ async function generateChangelogForProjects(tree, args, projectGraph, commits, p
                 changelogContents = contents;
             }
             tree.write(interpolatedTreePath, changelogContents);
-            printSummary = () => (0, print_changes_1.printAndFlushChanges)(tree, !!dryRun, 3, false, noDiffInChangelogMessage, 
+            (0, print_changes_1.printAndFlushChanges)(tree, !!dryRun, 3, false, shared_1.noDiffInChangelogMessage, 
             // Only print the change for the current changelog file at this point
             (f) => f.path === interpolatedTreePath);
         }
-        if (config.createRelease === 'github') {
-            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 (0, github_1.resolveGithubToken)();
-            const githubRequestConfig = {
-                repo: githubRepoSlug,
-                token,
-            };
-            let existingGithubReleaseForVersion;
-            try {
-                existingGithubReleaseForVersion = await (0, github_1.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;
-                }
-            }
-            let existingPrintSummaryFn = printSummary;
-            printSummary = () => {
-                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]') : ''}`);
-                }
-                // Only print the diff here if we are not already going to be printing changes from the Tree
-                if (!interpolatedTreePath) {
-                    console.log('');
-                    (0, print_changes_1.printDiff)(existingGithubReleaseForVersion
-                        ? existingGithubReleaseForVersion.body
-                        : '', contents, 3, noDiffInChangelogMessage);
-                }
-                existingPrintSummaryFn();
-            };
-            // Only schedule the actual GitHub update when not in dry-run mode
-            if (!dryRun) {
-                postGitTasks.push(async (latestCommit) => {
-                    // Before we can create/update the release we need to ensure the commit exists on the remote
-                    await (0, git_1.gitPush)(gitRemote);
-                    await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
-                        version: releaseVersion.gitTag,
-                        prerelease: releaseVersion.isPrerelease,
-                        body: contents,
-                        commit: latestCommit,
-                    }, existingGithubReleaseForVersion);
-                });
-            }
-        }
-        printSummary();
+        projectChangelogs[project.name] = {
+            releaseVersion,
+            contents,
+        };
     }
+    return projectChangelogs;
 }
 function checkChangelogFilesEnabled(nxReleaseConfig) {
     if (nxReleaseConfig.changelog.workspaceChangelog &&
@@ -690,3 +593,10 @@ async function getCommits(fromSHA, toSHA) {
         return false;
     });
 }
+function shouldCreateGitHubRelease(changelogConfig, createReleaseArg = undefined) {
+    if (createReleaseArg !== undefined) {
+        return createReleaseArg === 'github';
+    }
+    return (changelogConfig || {}).createRelease === 'github';
+}
+exports.shouldCreateGitHubRelease = shouldCreateGitHubRelease;

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

@@ -29,6 +29,7 @@ export type ChangelogOptions = NxReleaseArgs & GitCommitAndTagOptions & {
     from?: string;
     interactive?: string;
     gitRemote?: string;
+    createRelease?: false | 'github';
 };
 export type PublishOptions = NxReleaseArgs & Partial<RunManyOptions> & {
     outputStyle?: OutputStyle;

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,6 +92,52 @@ async function release(args) {
             });
         }
     }
+    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) {

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;