nx 17.2.0-beta.1 → 17.2.0-beta.10

package/bin/nx.js

@@ -38,22 +38,6 @@ function main() {
         require('nx/src/command-line/nx-commands').commandsObject.argv;
     }
     else {
-        // v8-compile-cache doesn't support ESM. Attempting to import ESM
-        // with it enabled results in an error that reads "Invalid host options".
-        //
-        // Angular CLI, and prettier both use ESM so we need to disable it in these cases.
-        if (workspace &&
-            workspace.type === 'nx' &&
-            ![
-                'format',
-                'format:check',
-                'format:write',
-                'g',
-                'generate',
-                'release',
-            ].some((cmd) => process.argv[2] === cmd)) {
-            require('v8-compile-cache');
-        }
         if (!client_1.daemonClient.enabled() && workspace !== null) {
             (0, workspace_context_1.setupWorkspaceContext)(workspace.dir);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "17.2.0-beta.1",
+  "version": "17.2.0-beta.10",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -63,11 +63,10 @@
     "tmp": "~0.2.1",
     "tsconfig-paths": "^4.1.2",
     "tslib": "^2.3.0",
-    "v8-compile-cache": "2.3.0",
     "yargs": "^17.6.2",
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
-    "@nrwl/tao": "17.2.0-beta.1"
+    "@nrwl/tao": "17.2.0-beta.10"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.6.7",
@@ -82,16 +81,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "17.2.0-beta.1",
-    "@nx/nx-darwin-arm64": "17.2.0-beta.1",
-    "@nx/nx-linux-x64-gnu": "17.2.0-beta.1",
-    "@nx/nx-linux-x64-musl": "17.2.0-beta.1",
-    "@nx/nx-win32-x64-msvc": "17.2.0-beta.1",
-    "@nx/nx-linux-arm64-gnu": "17.2.0-beta.1",
-    "@nx/nx-linux-arm64-musl": "17.2.0-beta.1",
-    "@nx/nx-linux-arm-gnueabihf": "17.2.0-beta.1",
-    "@nx/nx-win32-arm64-msvc": "17.2.0-beta.1",
-    "@nx/nx-freebsd-x64": "17.2.0-beta.1"
+    "@nx/nx-darwin-x64": "17.2.0-beta.10",
+    "@nx/nx-darwin-arm64": "17.2.0-beta.10",
+    "@nx/nx-linux-x64-gnu": "17.2.0-beta.10",
+    "@nx/nx-linux-x64-musl": "17.2.0-beta.10",
+    "@nx/nx-win32-x64-msvc": "17.2.0-beta.10",
+    "@nx/nx-linux-arm64-gnu": "17.2.0-beta.10",
+    "@nx/nx-linux-arm64-musl": "17.2.0-beta.10",
+    "@nx/nx-linux-arm-gnueabihf": "17.2.0-beta.10",
+    "@nx/nx-win32-arm64-msvc": "17.2.0-beta.10",
+    "@nx/nx-freebsd-x64": "17.2.0-beta.10"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/command-line/affected/print-affected.js

@@ -9,6 +9,8 @@ const package_manager_1 = require("../../utils/package-manager");
 const command_object_1 = require("./command-object");
 const logger_1 = require("../../utils/logger");
 const task_env_1 = require("../../tasks-runner/task-env");
+const build_project_graph_1 = require("../../project-graph/build-project-graph");
+const client_1 = require("../../daemon/client/client");
 /**
  * @deprecated Use showProjectsHandler, generateGraph, or affected (without the print-affected mode) instead.
  */
@@ -35,7 +37,14 @@ exports.printAffected = printAffected;
 async function createTasks(affectedProjectsWithTargetAndConfig, projectGraph, nxArgs, nxJson, overrides) {
     const defaultDependencyConfigs = (0, create_task_graph_1.mapTargetDefaultsToDependencies)(nxJson.targetDefaults);
     const taskGraph = (0, create_task_graph_1.createTaskGraph)(projectGraph, defaultDependencyConfigs, affectedProjectsWithTargetAndConfig.map((p) => p.name), nxArgs.targets, nxArgs.configuration, overrides);
-    const hasher = new task_hasher_1.InProcessTaskHasher({}, [], projectGraph, nxJson, {});
+    let hasher;
+    if (client_1.daemonClient.enabled()) {
+        hasher = new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, {});
+    }
+    else {
+        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        hasher = new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, {});
+    }
     const execCommand = (0, package_manager_1.getPackageManagerCommand)().exec;
     const tasks = Object.values(taskGraph.tasks);
     await Promise.all(tasks.map((t) => (0, hash_task_1.hashTask)(hasher, projectGraph, taskGraph, t, 

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

@@ -15,7 +15,6 @@ const fileutils_1 = require("../../utils/fileutils");
 const output_1 = require("../../utils/output");
 const workspace_root_1 = require("../../utils/workspace-root");
 const client_1 = require("../../daemon/client/client");
-const task_hasher_1 = require("../../hasher/task-hasher");
 const typescript_1 = require("../../plugins/js/utils/typescript");
 const operators_1 = require("../../project-graph/operators");
 const project_graph_1 = require("../../project-graph/project-graph");
@@ -26,6 +25,7 @@ const native_1 = require("../../native");
 const transform_objects_1 = require("../../native/transform-objects");
 const affected_1 = require("../affected/affected");
 const nx_deps_cache_1 = require("../../project-graph/nx-deps-cache");
+const task_hasher_1 = require("../../hasher/task-hasher");
 // maps file extention to MIME types
 const mimeType = {
     '.ico': 'image/x-icon',
@@ -435,7 +435,7 @@ async function createTaskGraphClientResponse(pruneExternal = false) {
     perf_hooks_1.performance.mark('task graph generation:start');
     const taskGraphs = getAllTaskGraphsForWorkspace(nxJson, graph);
     perf_hooks_1.performance.mark('task graph generation:end');
-    const planner = new native_1.HashPlanner(workspace_root_1.workspaceRoot, nxJson, (0, transform_objects_1.transformProjectGraphForRust)(graph));
+    const planner = new native_1.HashPlanner(nxJson, (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(graph)));
     perf_hooks_1.performance.mark('task hash plan generation:start');
     const plans = {};
     for (const individualTaskGraph of Object.values(taskGraphs.taskGraphs)) {

package/src/command-line/init/implementation/add-nx-to-nest.js

@@ -173,7 +173,7 @@ function createProjectJson(repoRoot, packageJson, nestCLIOptions) {
             executor: '@nx/eslint:lint',
             outputs: ['{options.outputFile}'],
             options: {
-                lintFilePatterns: ['src/**/*.ts', 'test/**/*.ts'],
+                lintFilePatterns: ['./src', './test'],
             },
         };
         // test and e2e

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

@@ -1,2 +1,8 @@
 import { ChangelogOptions } from './command-object';
-export declare function changelogHandler(args: ChangelogOptions): Promise<number>;
+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>;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.changelogHandler = void 0;
+exports.releaseChangelog = exports.releaseChangelogCLIHandler = void 0;
 const chalk = require("chalk");
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
@@ -24,103 +24,158 @@ const launch_editor_1 = require("./utils/launch-editor");
 const markdown_1 = require("./utils/markdown");
 const print_changes_1 = require("./utils/print-changes");
 const shared_1 = require("./utils/shared");
-async function changelogHandler(args) {
-    return (0, params_1.handleErrors)(args.verbose, async () => {
-        // Right now, the given version must be valid semver in order to proceed
-        if (!(0, semver_1.valid)(args.version)) {
-            throw new Error(`The given version "${args.version}" is not a valid semver version. Please provide your version in the format "1.0.0", "1.0.0-beta.1" etc`);
-        }
-        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
-        const nxJson = (0, nx_json_1.readNxJson)();
-        if (args.verbose) {
-            process.env.NX_VERBOSE_LOGGING = 'true';
-        }
-        // Apply default configuration to any optional user configuration
-        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, nxJson.release);
-        if (configError) {
-            return await (0, config_1.handleNxReleaseConfigError)(configError);
+const releaseChangelogCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => releaseChangelog(args));
+exports.releaseChangelogCLIHandler = releaseChangelogCLIHandler;
+/**
+ * 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.
+ */
+async function releaseChangelog(args) {
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const nxJson = (0, nx_json_1.readNxJson)();
+    if (args.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    // Apply default configuration to any optional user configuration
+    const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, nxJson.release);
+    if (configError) {
+        return await (0, config_1.handleNxReleaseConfigError)(configError);
+    }
+    const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+    if (filterError) {
+        output_1.output.error(filterError);
+        process.exit(1);
+    }
+    /**
+     * For determining the versions to use within changelog files, there are a few different possibilities:
+     * - the user is using the nx CLI, and therefore passes a single --version argument which represents the version for any and all changelog
+     * files which will be generated (i.e. both the workspace changelog, and all project changelogs, depending on which of those has been enabled)
+     * - the user is using the nxReleaseChangelog API programmatically, and:
+     *   - passes only a version property
+     *     - this works in the same way as described above for the CLI
+     *   - passes only a versionData object
+     *     - this is a special case where the user is providing a version for each project, and therefore the version argument is not needed
+     *     - NOTE: it is not possible to generate a workspace level changelog with only a versionData object, and this will produce an error
+     *   - passes both a version and a versionData object
+     *     - in this case, the version property will be used as the reference for the workspace changelog, and the versionData object will be used
+     *    to generate project changelogs
+     */
+    const { workspaceChangelogVersion, projectsVersionData } = resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects);
+    const to = args.to || 'HEAD';
+    const toSHA = await (0, git_1.getCommitHash)(to);
+    const headSHA = to === 'HEAD' ? toSHA : await (0, git_1.getCommitHash)('HEAD');
+    /**
+     * Protect the user against attempting to create a new commit when recreating an old release changelog,
+     * this seems like it would always be unintentional.
+     */
+    const autoCommitEnabled = args.gitCommit ?? nxReleaseConfig.changelog.git.commit;
+    if (autoCommitEnabled && headSHA !== toSHA) {
+        throw new Error(`You are attempting to recreate the changelog for an old release, but you have enabled auto-commit mode. Please disable auto-commit mode by updating your nx.json, or passing --git-commit=false`);
+    }
+    const fromRef = args.from ||
+        (await (0, git_1.getLatestGitTagForPattern)(nxReleaseConfig.releaseTagPattern))?.tag;
+    if (!fromRef) {
+        throw new Error(`Unable to determine the previous git tag, please provide an explicit git reference using --from`);
+    }
+    // Make sure that the fromRef is actually resolvable
+    const fromSHA = await (0, git_1.getCommitHash)(fromRef);
+    const rawCommits = await (0, git_1.getGitDiff)(fromSHA, toSHA);
+    // Parse as conventional commits
+    const commits = (0, git_1.parseCommits)(rawCommits).filter((c) => {
+        const type = c.type;
+        // Always ignore non user-facing commits for now
+        // TODO: allow this filter to be configurable via config in a future release
+        if (type === 'feat' || type === 'fix' || type === 'perf') {
+            return true;
         }
-        const toSHA = await (0, git_1.getCommitHash)(args.to);
-        const headSHA = args.to === 'HEAD' ? toSHA : await (0, git_1.getCommitHash)('HEAD');
+        return false;
+    });
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+    const userCommitMessage = args.gitCommitMessage || nxReleaseConfig.changelog.git.commitMessage;
+    const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, projectsVersionData, userCommitMessage);
+    // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
+    const gitTagValues = args.gitTag ?? nxReleaseConfig.changelog.git.tag
+        ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, projectsVersionData)
+        : [];
+    (0, shared_1.handleDuplicateGitTags)(gitTagValues);
+    const postGitTasks = [];
+    await generateChangelogForWorkspace(tree, args, nxReleaseConfig, workspaceChangelogVersion, commits, postGitTasks);
+    if (args.projects?.length) {
         /**
-         * Protect the user against attempting to create a new commit when recreating an old release changelog,
-         * this seems like it would always be unintentional.
+         * Run changelog generation for all remaining release groups and filtered projects within them
          */
-        const autoCommitEnabled = args.gitCommit ?? nxReleaseConfig.changelog.git.commit;
-        if (autoCommitEnabled && headSHA !== toSHA) {
-            throw new Error(`You are attempting to recreate the changelog for an old release, but you have enabled auto-commit mode. Please disable auto-commit mode by updating your nx.json, or passing --git-commit=false`);
-        }
-        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
-        if (filterError) {
-            output_1.output.error(filterError);
-            process.exit(1);
-        }
-        const fromRef = args.from ||
-            (await (0, git_1.getLatestGitTagForPattern)(nxReleaseConfig.releaseTagPattern))?.tag;
-        if (!fromRef) {
-            throw new Error(`Unable to determine the previous git tag, please provide an explicit git reference using --from`);
+        for (const releaseGroup of releaseGroups) {
+            const projectNodes = Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).map((name) => projectGraph.nodes[name]);
+            await generateChangelogForProjects(tree, args, commits, projectsVersionData, postGitTasks, releaseGroup, projectNodes);
         }
-        // Make sure that the fromRef is actually resolvable
-        const fromSHA = await (0, git_1.getCommitHash)(fromRef);
-        const rawCommits = await (0, git_1.getGitDiff)(fromSHA, toSHA);
-        // Parse as conventional commits
-        const commits = (0, git_1.parseCommits)(rawCommits).filter((c) => {
-            const type = c.type;
-            // Always ignore non user-facing commits for now
-            // TODO: allow this filter to be configurable via config in a future release
-            if (type === 'feat' || type === 'fix' || type === 'perf') {
-                return true;
-            }
-            return false;
-        });
-        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-        // Create a pseudo-versionData object using the version passed into the command so that we can share commit and tagging utils with version
-        const versionData = releaseGroups.reduce((versionData, releaseGroup) => {
-            const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
-            for (const projectName of releaseGroupProjectNames) {
+        return await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
+    }
+    /**
+     * Run changelog generation for all remaining release groups
+     */
+    for (const releaseGroup of releaseGroups) {
+        const projectNodes = releaseGroup.projects.map((name) => projectGraph.nodes[name]);
+        await generateChangelogForProjects(tree, args, commits, projectsVersionData, postGitTasks, releaseGroup, projectNodes);
+    }
+    return await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
+}
+exports.releaseChangelog = releaseChangelog;
+function resolveChangelogVersions(args, releaseGroups, releaseGroupToFilteredProjects) {
+    if (!args.version && !args.versionData) {
+        throw new Error(`You must provide a version string and/or a versionData object.`);
+    }
+    /**
+     * TODO: revaluate this assumption holistically in a dedicated PR when we add support for calver
+     * (e.g. the Release class also uses semver utils to check if prerelease).
+     *
+     * Right now, the given version must be valid semver in order to proceed
+     */
+    if (args.version && !(0, semver_1.valid)(args.version)) {
+        throw new Error(`The given version "${args.version}" is not a valid semver version. Please provide your version in the format "1.0.0", "1.0.0-beta.1" etc`);
+    }
+    const versionData = releaseGroups.reduce((versionData, releaseGroup) => {
+        const releaseGroupProjectNames = Array.from(releaseGroupToFilteredProjects.get(releaseGroup));
+        for (const projectName of releaseGroupProjectNames) {
+            if (!args.versionData) {
                 versionData[projectName] = {
                     newVersion: args.version,
                     currentVersion: '',
-                    dependentProjects: [], // not needed within changelog/commit generation
+                    dependentProjects: [], // not relevant within changelog/commit generation
                 };
+                continue;
             }
-            return versionData;
-        }, {});
-        const userCommitMessage = args.gitCommitMessage || nxReleaseConfig.changelog.git.commitMessage;
-        const commitMessageValues = (0, shared_1.createCommitMessageValues)(releaseGroups, releaseGroupToFilteredProjects, versionData, userCommitMessage);
-        // Resolve any git tags as early as possible so that we can hard error in case of any duplicates before reaching the actual git command
-        const gitTagValues = args.gitTag ?? nxReleaseConfig.changelog.git.tag
-            ? (0, shared_1.createGitTagValues)(releaseGroups, releaseGroupToFilteredProjects, versionData)
-            : [];
-        (0, shared_1.handleDuplicateGitTags)(gitTagValues);
-        const postGitTasks = [];
-        await generateChangelogForWorkspace(tree, args, nxReleaseConfig, commits, postGitTasks);
-        if (args.projects?.length) {
             /**
-             * Run changelog generation for all remaining release groups and filtered projects within them
+             * In the case where a versionData object was provided, we need to make sure all projects are present,
+             * otherwise it suggests a filtering mismatch between the version and changelog command invocations.
              */
-            for (const releaseGroup of releaseGroups) {
-                const projectNodes = Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).map((name) => projectGraph.nodes[name]);
-                await generateChangelogForProjects(tree, args, commits, postGitTasks, releaseGroup, projectNodes);
+            if (!args.versionData[projectName]) {
+                throw new Error(`The provided versionData object does not contain a version for project "${projectName}". This suggests a filtering mismatch between the version and changelog command invocations.`);
             }
-            return await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
-        }
-        /**
-         * Run changelog generation for all remaining release groups
-         */
-        for (const releaseGroup of releaseGroups) {
-            const projectNodes = releaseGroup.projects.map((name) => projectGraph.nodes[name]);
-            await generateChangelogForProjects(tree, args, commits, postGitTasks, releaseGroup, projectNodes);
         }
-        return await applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues);
-    });
+        return versionData;
+    }, args.versionData || {});
+    return {
+        workspaceChangelogVersion: args.version,
+        projectsVersionData: versionData,
+    };
 }
-exports.changelogHandler = changelogHandler;
 async function applyChangesAndExit(args, nxReleaseConfig, tree, toSHA, postGitTasks, commitMessageValues, gitTagValues) {
     let latestCommit = toSHA;
+    const changes = tree.listChanges();
+    // This could happen we using conventional commits, for example
+    if (!changes.length) {
+        output_1.output.warn({
+            title: `No changes detected for changelogs`,
+            bodyLines: [
+                `No changes were detected for any changelog files, so no changelog entries will be generated.`,
+            ],
+        });
+        return 0;
+    }
     // Generate a new commit for the changes, if configured to do so
     if (args.gitCommit ?? nxReleaseConfig.changelog.git.commit) {
-        await (0, shared_1.commitChanges)(tree.listChanges().map((f) => f.path), !!args.dryRun, !!args.verbose, commitMessageValues, args.gitCommitArgs || nxReleaseConfig.changelog.git.commitArgs);
+        await (0, shared_1.commitChanges)(changes.map((f) => f.path), !!args.dryRun, !!args.verbose, commitMessageValues, args.gitCommitArgs || nxReleaseConfig.changelog.git.commitArgs);
         // Resolve the commit we just made
         latestCommit = await (0, git_1.getCommitHash)('HEAD');
     }
@@ -165,16 +220,22 @@ function resolveChangelogRenderer(changelogRendererPath) {
     }
     return changelogRenderer;
 }
-async function generateChangelogForWorkspace(tree, args, nxReleaseConfig, commits, postGitTasks) {
+async function generateChangelogForWorkspace(tree, args, nxReleaseConfig, workspaceChangelogVersion, commits, postGitTasks) {
     const config = nxReleaseConfig.changelog.workspaceChangelog;
     // The entire feature is disabled at the workspace level, exit early
     if (config === false) {
         return;
     }
+    // If explicitly null it must mean that no changes were detected (e.g. when using conventional commits), so do nothing
+    if (workspaceChangelogVersion === null) {
+        return;
+    }
+    if (!workspaceChangelogVersion) {
+        throw new Error(`Workspace changelog is enabled but no overall version was provided. Please provide an explicit version using --version`);
+    }
     // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "workspace"
     const interactive = args.interactive === 'all' || args.interactive === 'workspace';
     const dryRun = !!args.dryRun;
-    const verbose = !!args.verbose;
     const gitRemote = args.gitRemote;
     const changelogRenderer = resolveChangelogRenderer(config.renderer);
     let interpolatedTreePath = config.file || '';
@@ -186,7 +247,7 @@ async function generateChangelogForWorkspace(tree, args, nxReleaseConfig, commit
         });
     }
     const releaseVersion = new shared_1.ReleaseVersion({
-        version: args.version,
+        version: workspaceChangelogVersion,
         releaseTagPattern: nxReleaseConfig.releaseTagPattern,
     });
     // We are either creating/previewing a changelog file, a Github release, or both
@@ -329,7 +390,7 @@ async function generateChangelogForWorkspace(tree, args, nxReleaseConfig, commit
     }
     printSummary();
 }
-async function generateChangelogForProjects(tree, args, commits, postGitTasks, releaseGroup, projects) {
+async function generateChangelogForProjects(tree, args, commits, projectsVersionData, postGitTasks, releaseGroup, projects) {
     const config = releaseGroup.changelog;
     // The entire feature is disabled at the release group level, exit early
     if (config === false) {
@@ -339,7 +400,6 @@ async function generateChangelogForProjects(tree, args, commits, postGitTasks, r
     const interactive = args.interactive === 'all' || args.interactive === 'projects';
     const dryRun = !!args.dryRun;
     const gitRemote = args.gitRemote;
-    const rawVersion = args.version;
     const changelogRenderer = resolveChangelogRenderer(config.renderer);
     for (const project of projects) {
         let interpolatedTreePath = config.file || '';
@@ -350,8 +410,15 @@ async function generateChangelogForProjects(tree, args, commits, postGitTasks, r
                 workspaceRoot: '', // within the tree, workspaceRoot is the root
             });
         }
+        /**
+         * newVersion will be null in the case that no changes were detected (e.g. in conventional commits mode),
+         * no changelog entry is relevant in that case.
+         */
+        if (projectsVersionData[project.name].newVersion === null) {
+            continue;
+        }
         const releaseVersion = new shared_1.ReleaseVersion({
-            version: rawVersion,
+            version: projectsVersionData[project.name].newVersion,
             releaseTagPattern: releaseGroup.releaseTagPattern,
             projectName: project.name,
         });

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

@@ -1,5 +1,6 @@
 import { CommandModule } from 'yargs';
-import { RunManyOptions } from '../yargs-utils/shared-options';
+import { OutputStyle, RunManyOptions } from '../yargs-utils/shared-options';
+import { VersionData } from './utils/shared';
 export interface NxReleaseArgs {
     groups?: string[];
     projects?: string[];
@@ -17,15 +18,19 @@ interface GitCommitAndTagOptions {
 export type VersionOptions = NxReleaseArgs & GitCommitAndTagOptions & {
     specifier?: string;
     preid?: string;
+    stageChanges?: boolean;
 };
 export type ChangelogOptions = NxReleaseArgs & GitCommitAndTagOptions & {
-    version: string;
-    to: string;
+    version?: string | null;
+    versionData?: VersionData;
+    to?: string;
     from?: string;
     interactive?: string;
     gitRemote?: string;
 };
-export type PublishOptions = NxReleaseArgs & RunManyOptions & {
+export type PublishOptions = NxReleaseArgs & Partial<RunManyOptions> & {
+    outputStyle?: OutputStyle;
+} & {
     registry?: string;
     tag?: string;
     otp?: number;

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

@@ -68,8 +68,19 @@ const versionCommand = {
         type: 'string',
         describe: 'The optional prerelease identifier to apply to the version, in the case that specifier has been set to prerelease.',
         default: '',
+    })
+        .option('stageChanges', {
+        type: 'boolean',
+        describe: 'Whether or not to stage the changes made by this command, irrespective of the git config in nx.json related to automated commits. Useful when combining this command with changelog generation.',
+        default: false,
     })),
-    handler: (args) => Promise.resolve().then(() => require('./version')).then((m) => m.versionHandler(args)),
+    handler: (args) => Promise.resolve().then(() => require('./version')).then((m) => m.releaseVersionCLIHandler(args))
+        .then((versionDataOrExitCode) => {
+        if (typeof versionDataOrExitCode === 'number') {
+            return process.exit(versionDataOrExitCode);
+        }
+        process.exit(0);
+    }),
 };
 const changelogCommand = {
     command: 'changelog [version]',
@@ -109,7 +120,7 @@ const changelogCommand = {
         return true;
     })),
     handler: async (args) => {
-        const status = await (await Promise.resolve().then(() => require('./changelog'))).changelogHandler(args);
+        const status = await (await Promise.resolve().then(() => require('./changelog'))).releaseChangelogCLIHandler(args);
         process.exit(status);
     },
 };
@@ -130,7 +141,7 @@ const publishCommand = {
         type: 'number',
         description: 'A one-time password for publishing to a registry that requires 2FA',
     }),
-    handler: (args) => Promise.resolve().then(() => require('./publish')).then((m) => m.publishHandler(coerceParallelOption((0, shared_options_1.withOverrides)(args, 2)))),
+    handler: (args) => Promise.resolve().then(() => require('./publish')).then((m) => m.releasePublishCLIHandler(coerceParallelOption((0, shared_options_1.withOverrides)(args, 2)))),
 };
 function coerceParallelOption(args) {
     if (args['parallel'] === 'false' || args['parallel'] === false) {

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

@@ -23,6 +23,13 @@ type EnsureProjectsArray<T> = {
         projects: string[];
     } : T[K];
 };
+type RemoveTrueFromType<T> = T extends true ? never : T;
+type RemoveTrueFromProperties<T, K extends keyof T> = {
+    [P in keyof T]: P extends K ? RemoveTrueFromType<T[P]> : T[P];
+};
+type RemoveTrueFromPropertiesOnEach<T, K extends keyof T[keyof T]> = {
+    [U in keyof T]: RemoveTrueFromProperties<T[U], K>;
+};
 export declare const CATCH_ALL_RELEASE_GROUP = "__default__";
 /**
  * Our source of truth is a deeply required variant of the user-facing config interface, so that command
@@ -34,7 +41,8 @@ export declare const CATCH_ALL_RELEASE_GROUP = "__default__";
  * pattern such as directories and globs).
  */
 export type NxReleaseConfig = DeepRequired<NxJsonConfiguration['release'] & {
-    groups: DeepRequired<EnsureProjectsArray<NxJsonConfiguration['release']['groups']>>;
+    groups: DeepRequired<RemoveTrueFromPropertiesOnEach<EnsureProjectsArray<NxJsonConfiguration['release']['groups']>, 'changelog'>>;
+    changelog: RemoveTrueFromProperties<DeepRequired<NxJsonConfiguration['release']['changelog']>, 'workspaceChangelog' | 'projectChangelogs'>;
 }>;
 export interface CreateNxReleaseConfigError {
     code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'RELEASE_GROUP_RELEASE_TAG_PATTERN_VERSION_PLACEHOLDER_MISSING_OR_EXCESSIVE' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'PROJECTS_MISSING_TARGET';
@@ -44,5 +52,5 @@ export declare function createNxReleaseConfig(projectGraph: ProjectGraph, userCo
     error: null | CreateNxReleaseConfigError;
     nxReleaseConfig: NxReleaseConfig | null;
 }>;
-export declare function handleNxReleaseConfigError(error: CreateNxReleaseConfigError): Promise<void>;
+export declare function handleNxReleaseConfigError(error: CreateNxReleaseConfigError): Promise<never>;
 export {};

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

@@ -92,15 +92,25 @@ requiredTargetName) {
         // Merge in the git defaults from the top level
         { git: rootGitConfig },
     ], userConfig.version);
+    if (userConfig.changelog?.workspaceChangelog) {
+        userConfig.changelog.workspaceChangelog = normalizeTrueToEmptyObject(userConfig.changelog.workspaceChangelog);
+    }
+    if (userConfig.changelog?.projectChangelogs) {
+        userConfig.changelog.projectChangelogs = normalizeTrueToEmptyObject(userConfig.changelog.projectChangelogs);
+    }
     const rootChangelogConfig = deepMergeDefaults([
         WORKSPACE_DEFAULTS.changelog,
         // Merge in the git defaults from the top level
         { git: rootGitConfig },
-    ], userConfig.changelog);
+    ], normalizeTrueToEmptyObject(userConfig.changelog));
     // git configuration is not supported at the group level, only the root/command level
     const rootVersionWithoutGit = { ...rootVersionConfig };
     delete rootVersionWithoutGit.git;
-    const allProjects = (0, find_matching_projects_1.findMatchingProjects)(['*'], projectGraph.nodes);
+    const allProjects = (0, find_matching_projects_1.findMatchingProjects)(['*'], projectGraph.nodes).filter(
+    // only include libs by default when the user has no groups config,
+    // because the default implementation assumes npm js packages
+    // and these will usually be libs
+    (project) => projectGraph.nodes[project].type === 'lib');
     const groups = userConfig.groups && Object.keys(userConfig.groups).length
         ? ensureProjectsConfigIsArray(userConfig.groups)
         : /**
@@ -183,6 +193,9 @@ requiredTargetName) {
             groupChangelogDefaults.push(rootChangelogConfig.projectChangelogs);
         }
         const projectsRelationship = releaseGroup.projectsRelationship || GROUP_DEFAULTS.projectsRelationship;
+        if (releaseGroup.changelog) {
+            releaseGroup.changelog = normalizeTrueToEmptyObject(releaseGroup.changelog);
+        }
         const groupDefaults = {
             projectsRelationship,
             projects: matchingProjects,
@@ -197,7 +210,7 @@ requiredTargetName) {
                 // The appropriate group default releaseTagPattern is dependent upon the projectRelationships
                 (projectsRelationship === 'independent'
                     ? defaultIndependentReleaseTagPattern
-                    : defaultFixedReleaseTagPattern),
+                    : userConfig.releaseTagPattern || defaultFixedReleaseTagPattern),
         };
         releaseGroups[releaseGroupName] = deepMergeDefaults([groupDefaults], {
             ...releaseGroup,
@@ -218,6 +231,14 @@ requiredTargetName) {
     };
 }
 exports.createNxReleaseConfig = createNxReleaseConfig;
+/**
+ * In some cases it is much cleaner and more intuitive for the user to be able to
+ * specify `true` in their config when they want to use the default config for a
+ * particular property, rather than having to specify an empty object.
+ */
+function normalizeTrueToEmptyObject(value) {
+    return value === true ? {} : value;
+}
 async function handleNxReleaseConfigError(error) {
     switch (error.code) {
         case 'RELEASE_GROUP_MATCHES_NO_PROJECTS':

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

@@ -0,0 +1,12 @@
+/**
+ * @public
+ */
+export { releaseChangelog } from './changelog';
+/**
+ * @public
+ */
+export { releasePublish } from './publish';
+/**
+ * @public
+ */
+export { releaseVersion } from './version';