nx 18.1.0-canary.20240210-b1d0294 → 18.1.0-canary.20240214-b625a79

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.1.0-canary.20240210-b1d0294",
+  "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.20240210-b1d0294"
+    "@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.20240210-b1d0294",
-    "@nx/nx-darwin-arm64": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-linux-x64-gnu": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-linux-x64-musl": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-win32-x64-msvc": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-linux-arm64-gnu": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-linux-arm64-musl": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-linux-arm-gnueabihf": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-win32-arm64-msvc": "18.1.0-canary.20240210-b1d0294",
-    "@nx/nx-freebsd-x64": "18.1.0-canary.20240210-b1d0294"
+    "@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/command-object.js

@@ -7,7 +7,7 @@ const logger_1 = require("../../utils/logger");
 const shared_options_1 = require("../yargs-utils/shared-options");
 exports.yargsReleaseCommand = {
     command: 'release',
-    describe: '**ALPHA**: Orchestrate versioning and publishing of applications and libraries',
+    describe: 'Orchestrate versioning and publishing of applications and libraries',
     builder: (yargs) => yargs
         .command(releaseCommand)
         .command(versionCommand)

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>;