nx 18.0.4 → 18.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "18.0.4",
+  "version": "18.0.6",
   "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.0.4"
+    "@nrwl/tao": "18.0.6"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -81,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "18.0.4",
-    "@nx/nx-darwin-arm64": "18.0.4",
-    "@nx/nx-linux-x64-gnu": "18.0.4",
-    "@nx/nx-linux-x64-musl": "18.0.4",
-    "@nx/nx-win32-x64-msvc": "18.0.4",
-    "@nx/nx-linux-arm64-gnu": "18.0.4",
-    "@nx/nx-linux-arm64-musl": "18.0.4",
-    "@nx/nx-linux-arm-gnueabihf": "18.0.4",
-    "@nx/nx-win32-arm64-msvc": "18.0.4",
-    "@nx/nx-freebsd-x64": "18.0.4"
+    "@nx/nx-darwin-x64": "18.0.6",
+    "@nx/nx-darwin-arm64": "18.0.6",
+    "@nx/nx-linux-x64-gnu": "18.0.6",
+    "@nx/nx-linux-x64-musl": "18.0.6",
+    "@nx/nx-win32-x64-msvc": "18.0.6",
+    "@nx/nx-linux-arm64-gnu": "18.0.6",
+    "@nx/nx-linux-arm64-musl": "18.0.6",
+    "@nx/nx-linux-arm-gnueabihf": "18.0.6",
+    "@nx/nx-win32-arm64-msvc": "18.0.6",
+    "@nx/nx-freebsd-x64": "18.0.6"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",
@@ -126,6 +126,7 @@
       "@nrwl/next",
       "@nx/node",
       "@nrwl/node",
+      "@nx/nuxt",
       "@nx/playwright",
       "@nx/plugin",
       "@nrwl/nx-plugin",

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

@@ -100,7 +100,9 @@ async function initializePlugin(pkgName, options) {
                 process.env.NX_ADD_PLUGINS !== 'false' &&
                     coreNxPlugins.includes(pkgName);
         }
-        await (0, child_process_2.runNxAsync)(`g ${pkgName}:${initGenerator} --keepExistingVersions${updatePackageScripts ? ' --updatePackageScripts' : ''}`);
+        await (0, child_process_2.runNxAsync)(`g ${pkgName}:${initGenerator} --keepExistingVersions${updatePackageScripts ? ' --updatePackageScripts' : ''}`, {
+            silent: !options.verbose,
+        });
     }
     catch (e) {
         spinner.fail();

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

@@ -266,7 +266,7 @@ async function generateGraph(args, affectedProjects) {
         const { app, url } = await startServer(html, environmentJs, args.host || '127.0.0.1', args.port || 4211, args.watch, affectedProjects, args.focus, args.groupByFolder, args.exclude);
         url.pathname = args.view;
         if (args.focus) {
-            url.pathname += '/' + args.focus;
+            url.pathname += '/' + encodeURIComponent(args.focus);
         }
         if (target) {
             url.pathname += '/' + target;

package/src/command-line/init/init-v2.js

@@ -17,6 +17,7 @@ const workspace_context_1 = require("../../utils/workspace-context");
 const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
 const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
 const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const path_1 = require("path");
 async function initHandler(options) {
     const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
     if (process.env.NX_VERSION) {
@@ -63,19 +64,23 @@ async function initHandler(options) {
         const pmc = (0, package_manager_1.getPackageManagerCommand)();
         (0, utils_1.createNxJsonFile)(repoRoot, [], [], {});
         (0, utils_1.updateGitIgnore)(repoRoot);
-        (0, utils_1.addDepsToPackageJson)(repoRoot, detectPluginsResponse?.plugins ?? []);
+        (0, utils_1.addDepsToPackageJson)(repoRoot, detectPluginsResponse.plugins);
         output_1.output.log({ title: '📦 Installing Nx' });
         (0, utils_1.runInstall)(repoRoot, pmc);
-        if (detectPluginsResponse) {
-            output_1.output.log({ title: '🔨 Configuring plugins' });
-            for (const plugin of detectPluginsResponse.plugins) {
-                (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${detectPluginsResponse.updatePackageScripts
-                    ? '--updatePackageScripts'
-                    : ''} --no-interactive`, {
-                    stdio: [0, 1, 2],
-                    cwd: repoRoot,
-                });
-            }
+        output_1.output.log({ title: '🔨 Configuring plugins' });
+        for (const plugin of detectPluginsResponse.plugins) {
+            (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${detectPluginsResponse.updatePackageScripts
+                ? '--updatePackageScripts'
+                : ''} --no-interactive`, {
+                stdio: [0, 1, 2],
+                cwd: repoRoot,
+            });
+        }
+        if (!detectPluginsResponse.updatePackageScripts) {
+            const rootPackageJsonPath = (0, path_1.join)(repoRoot, 'package.json');
+            const json = (0, fileutils_1.readJsonFile)(rootPackageJsonPath);
+            json.nx = {};
+            (0, fileutils_1.writeJsonFile)(rootPackageJsonPath, json);
         }
         if (useNxCloud) {
             output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });

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

@@ -109,7 +109,8 @@ function runMigration() {
 }
 function nxCliPath() {
     try {
-        const packageManager = (0, package_manager_1.getPackageManagerCommand)();
+        const packageManager = (0, package_manager_1.detectPackageManager)();
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
         const { dirSync } = require('tmp');
         const tmpDir = dirSync().name;
         const version = process.env.NX_MIGRATE_USE_NEXT === 'true' ? 'next' : 'latest';
@@ -119,7 +120,21 @@ function nxCliPath() {
             },
             license: 'MIT',
         });
-        (0, child_process_2.execSync)(packageManager.install, {
+        if (pmc.preInstall) {
+            // ensure package.json and repo in tmp folder is set to a proper package manager state
+            (0, child_process_2.execSync)(pmc.preInstall, {
+                cwd: tmpDir,
+                stdio: ['ignore', 'ignore', 'ignore'],
+            });
+            // if it's berry ensure we set the node_linker to node-modules
+            if (packageManager === 'yarn' && pmc.ciInstall.includes('immutable')) {
+                (0, child_process_2.execSync)(pmc.preInstall, {
+                    cwd: 'yarn config set nodeLinker node-modules',
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                });
+            }
+        }
+        (0, child_process_2.execSync)(pmc.install, {
             cwd: tmpDir,
             stdio: ['ignore', 'ignore', 'ignore'],
         });

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

@@ -862,7 +862,19 @@ 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)(normalizeVersion(a.version), normalizeVersion(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;