nx 17.0.1 → 17.0.3

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

@@ -5,40 +5,62 @@ const chalk = require("chalk");
 const node_fs_1 = require("node:fs");
 const semver_1 = require("semver");
 const tmp_1 = require("tmp");
+const nx_json_1 = require("../../config/nx-json");
 const tree_1 = require("../../generators/tree");
+const register_1 = require("../../plugins/js/utils/register");
+const project_graph_1 = require("../../project-graph/project-graph");
+const utils_1 = require("../../tasks-runner/utils");
 const logger_1 = require("../../utils/logger");
 const output_1 = require("../../utils/output");
 const path_1 = require("../../utils/path");
+const typescript_1 = require("../../utils/typescript");
 const workspace_root_1 = require("../../utils/workspace-root");
+const config_1 = require("./config/config");
+const filter_release_groups_1 = require("./config/filter-release-groups");
 const git_1 = require("./utils/git");
 const github_1 = require("./utils/github");
 const launch_editor_1 = require("./utils/launch-editor");
 const markdown_1 = require("./utils/markdown");
 const print_changes_1 = require("./utils/print-changes");
+class ReleaseVersion {
+    constructor({ version, // short form version string with no prefixes or patterns, e.g. 1.0.0
+    releaseTagPattern, // full pattern to interpolate, e.g. "v{version}" or "{projectName}@{version}"
+    projectName, // optional project name to interpolate into the releaseTagPattern
+     }) {
+        this.rawVersion = version;
+        this.gitTag = (0, utils_1.interpolate)(releaseTagPattern, {
+            version,
+            projectName,
+        });
+        this.isPrerelease = isPrerelease(version);
+    }
+}
 async function changelogHandler(args) {
-    /**
-     * TODO: allow the prefix and version to be controllable via config as well once we flesh out
-     * changelog customization, and how it will interact with independently released projects.
-     */
-    const tagVersionPrefix = args.tagVersionPrefix ?? 'v';
-    // Allow the user to pass the version with or without the prefix already applied
-    const releaseVersion = args.version.startsWith(tagVersionPrefix)
-        ? args.version
-        : `${tagVersionPrefix}${args.version}`;
-    // We are either creating/previewing a changelog file, a Github release, or both
-    let logTitle = args.dryRun ? 'Previewing a ' : 'Generating a ';
-    switch (true) {
-        case args.file !== false && args.createRelease === 'github':
-            logTitle += `${args.file} entry and a Github release for ${chalk.white(releaseVersion)}`;
-            break;
-        case args.file !== false:
-            logTitle += `${args.file} entry for ${chalk.white(releaseVersion)}`;
-            break;
-        case args.createRelease === 'github':
-            logTitle += `Github release for ${chalk.white(releaseVersion)}`;
+    // Right now, the given version must be valid semver in order to proceed
+    if (!(0, semver_1.valid)(args.version)) {
+        output_1.output.error({
+            title: `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`,
+        });
+        process.exit(1);
     }
-    output_1.output.log({
-        title: logTitle,
+    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);
+    }
+    const releaseVersion = new ReleaseVersion({
+        version: args.version,
+        releaseTagPattern: nxReleaseConfig.releaseTagPattern,
     });
     const from = args.from || (await (0, git_1.getLastGitTag)());
     if (!from) {
@@ -58,38 +80,141 @@ async function changelogHandler(args) {
         }
         return false;
     });
-    const githubRepoSlug = args.createRelease === 'github'
-        ? (0, github_1.getGitHubRepoSlug)(args.gitRemote)
+    const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
+    await generateChangelogForWorkspace(tree, releaseVersion, !!args.dryRun, 
+    // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "workspace"
+    args.interactive === 'all' || args.interactive === 'workspace', commits, nxReleaseConfig.changelog.workspaceChangelog, args.gitRemote);
+    if (args.projects?.length) {
+        /**
+         * Run changelog generation for all remaining release groups and filtered projects within them
+         */
+        for (const releaseGroup of releaseGroups) {
+            const projectNodes = Array.from(releaseGroupToFilteredProjects.get(releaseGroup)).map((name) => projectGraph.nodes[name]);
+            await generateChangelogForProjects(tree, args.version, !!args.dryRun, 
+            // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "projects"
+            args.interactive === 'all' || args.interactive === 'projects', commits, releaseGroup.changelog, releaseGroup.releaseTagPattern, projectNodes, args.gitRemote);
+        }
+        return process.exit(0);
+    }
+    /**
+     * 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.version, !!args.dryRun, 
+        // Only trigger interactive mode for the workspace changelog if the user explicitly requested it via "all" or "projects"
+        args.interactive === 'all' || args.interactive === 'projects', commits, releaseGroup.changelog, releaseGroup.releaseTagPattern, projectNodes, args.gitRemote);
+    }
+    if (args.dryRun) {
+        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changelogs were actually created.`);
+    }
+    process.exit(0);
+}
+exports.changelogHandler = changelogHandler;
+function isPrerelease(version) {
+    // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
+    return (0, semver_1.prerelease)(version) !== null;
+}
+function resolveChangelogRenderer(changelogRendererPath) {
+    // Try and load the provided (or default) changelog renderer
+    let changelogRenderer;
+    let cleanupTranspiler = () => { };
+    try {
+        const rootTsconfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (rootTsconfigPath) {
+            cleanupTranspiler = (0, register_1.registerTsProject)(rootTsconfigPath);
+        }
+        const r = require(changelogRendererPath);
+        changelogRenderer = r.default || r;
+    }
+    catch {
+    }
+    finally {
+        cleanupTranspiler();
+    }
+    return changelogRenderer;
+}
+async function generateChangelogForWorkspace(tree, releaseVersion, dryRun, interactive, commits, config, gitRemote) {
+    // The entire feature is disabled at the workspace level, exit early
+    if (config === false) {
+        return;
+    }
+    const changelogRenderer = resolveChangelogRenderer(config.renderer);
+    let interpolatedTreePath = config.file || '';
+    if (interpolatedTreePath) {
+        interpolatedTreePath = (0, utils_1.interpolate)(interpolatedTreePath, {
+            projectName: '',
+            projectRoot: '',
+            workspaceRoot: '', // within the tree, workspaceRoot is the root
+        });
+    }
+    // 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,
+    });
+    const githubRepoSlug = config.createRelease === 'github'
+        ? (0, github_1.getGitHubRepoSlug)(gitRemote)
         : undefined;
-    const finalMarkdown = await resolveFinalMarkdown(args, commits, releaseVersion, githubRepoSlug);
+    let contents = await changelogRenderer({
+        commits,
+        releaseVersion: releaseVersion.rawVersion,
+        project: null,
+        repoSlug: githubRepoSlug,
+        entryWhenNoChanges: config.entryWhenNoChanges,
+        changelogRenderOptions: config.renderOptions,
+    });
+    /**
+     * If interactive mode, make the changelog contents available for the user to modify in their editor of choice,
+     * in a similar style to git interactive rebases/merges.
+     */
+    if (interactive) {
+        const tmpDir = (0, tmp_1.dirSync)().name;
+        const changelogPath = (0, path_1.joinPathFragments)(tmpDir, 
+        // Include the tree path in the name so that it is easier to identify which changelog file is being edited
+        `PREVIEW__${interpolatedTreePath.replace(/\//g, '_')}`);
+        (0, node_fs_1.writeFileSync)(changelogPath, contents);
+        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.md file, a Github release, or both.
+     * 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 (args.file !== false) {
-        const tree = new tree_1.FsTree(workspace_root_1.workspaceRoot, args.verbose);
-        let rootChangelogContents = tree.read(args.file)?.toString() ?? '';
+    if (interpolatedTreePath) {
+        let rootChangelogContents = tree.read(interpolatedTreePath)?.toString() ?? '';
         if (rootChangelogContents) {
-            const changelogReleases = (0, markdown_1.parseChangelogMarkdown)(rootChangelogContents, args.tagVersionPrefix).releases;
-            const existingVersionToUpdate = changelogReleases.find((r) => `${tagVersionPrefix}${r.version}` === releaseVersion);
+            // NOTE: right now existing releases are always expected to be in markdown format, but in the future we could potentially support others via a custom parser option
+            const changelogReleases = (0, markdown_1.parseChangelogMarkdown)(rootChangelogContents).releases;
+            const existingVersionToUpdate = changelogReleases.find((r) => r.version === releaseVersion.rawVersion);
             if (existingVersionToUpdate) {
-                rootChangelogContents = rootChangelogContents.replace(`## ${releaseVersion}\n\n\n${existingVersionToUpdate.body}`, finalMarkdown);
+                rootChangelogContents = rootChangelogContents.replace(`## ${releaseVersion.rawVersion}\n\n\n${existingVersionToUpdate.body}`, contents);
             }
             else {
                 // No existing version, simply prepend the new release to the top of the file
-                rootChangelogContents = `${finalMarkdown}\n\n${rootChangelogContents}`;
+                rootChangelogContents = `${contents}\n\n${rootChangelogContents}`;
             }
         }
         else {
-            // No existing changelog contents, simply create a new one using the generated markdown
-            rootChangelogContents = finalMarkdown;
+            // No existing changelog contents, simply create a new one using the generated contents
+            rootChangelogContents = contents;
         }
-        tree.write(args.file, rootChangelogContents);
-        printSummary = () => (0, print_changes_1.printChanges)(tree, !!args.dryRun, 3, false, noDiffInChangelogMessage);
+        tree.write(interpolatedTreePath, rootChangelogContents);
+        printSummary = () => (0, print_changes_1.printChanges)(tree, !!dryRun, 3, false, noDiffInChangelogMessage);
     }
-    if (args.createRelease === 'github') {
+    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.`,
@@ -106,7 +231,7 @@ async function changelogHandler(args) {
         };
         let existingGithubReleaseForVersion;
         try {
-            existingGithubReleaseForVersion = await (0, github_1.getGithubReleaseByTag)(githubRequestConfig, releaseVersion);
+            existingGithubReleaseForVersion = await (0, github_1.getGithubReleaseByTag)(githubRequestConfig, releaseVersion.gitTag);
         }
         catch (err) {
             if (err.response?.status === 401) {
@@ -129,58 +254,190 @@ async function changelogHandler(args) {
         }
         let existingPrintSummaryFn = printSummary;
         printSummary = () => {
-            const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion}`;
+            const logTitle = `https://github.com/${githubRepoSlug}/releases/tag/${releaseVersion.gitTag}`;
             if (existingGithubReleaseForVersion) {
-                console.error(`${chalk.white('UPDATE')} ${logTitle}${args.dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+                console.error(`${chalk.white('UPDATE')} ${logTitle}${dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
             }
             else {
-                console.error(`${chalk.green('CREATE')} ${logTitle}${args.dryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
+                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 (args.file === false) {
+            if (!interpolatedTreePath) {
                 console.log('');
                 (0, print_changes_1.printDiff)(existingGithubReleaseForVersion
                     ? existingGithubReleaseForVersion.body
-                    : '', finalMarkdown, 3, noDiffInChangelogMessage);
+                    : '', contents, 3, noDiffInChangelogMessage);
             }
             existingPrintSummaryFn();
         };
-        if (!args.dryRun) {
+        if (!dryRun) {
             await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
-                version: releaseVersion,
-                body: finalMarkdown,
-                prerelease: isPrerelease(releaseVersion.replace(args.tagVersionPrefix, '')),
+                version: releaseVersion.gitTag,
+                prerelease: releaseVersion.isPrerelease,
+                body: contents,
             }, existingGithubReleaseForVersion);
         }
     }
     printSummary();
-    if (args.dryRun) {
-        logger_1.logger.warn(`\nNOTE: The "dryRun" flag means no changes were made.`);
-    }
-    process.exit(0);
 }
-exports.changelogHandler = changelogHandler;
-/**
- * Based on the commits available, and some optional additional user modifications,
- * generate the final markdown for the changelog which will be used for a CHANGELOG.md
- * file and/or a Github release.
- */
-async function resolveFinalMarkdown(args, commits, releaseVersion, githubRepoSlug) {
-    let markdown = await (0, markdown_1.generateMarkdown)(commits, releaseVersion, githubRepoSlug);
-    /**
-     * If interactive mode, make the markdown available for the user to modify in their editor of choice,
-     * in a similar style to git interactive rebases/merges.
-     */
-    if (args.interactive) {
-        const tmpDir = (0, tmp_1.dirSync)().name;
-        const changelogPath = (0, path_1.joinPathFragments)(tmpDir, 'c.md');
-        (0, node_fs_1.writeFileSync)(changelogPath, markdown);
-        await (0, launch_editor_1.launchEditor)(changelogPath);
-        markdown = (0, node_fs_1.readFileSync)(changelogPath, 'utf-8');
+async function generateChangelogForProjects(tree, rawVersion, dryRun, interactive, commits, config, releaseTagPattern, projects, gitRemote) {
+    // The entire feature is disabled at the project level, exit early
+    if (config === false) {
+        return;
+    }
+    const changelogRenderer = resolveChangelogRenderer(config.renderer);
+    for (const project of projects) {
+        let interpolatedTreePath = config.file || '';
+        if (interpolatedTreePath) {
+            interpolatedTreePath = (0, utils_1.interpolate)(interpolatedTreePath, {
+                projectName: project.name,
+                projectRoot: project.data.root,
+                workspaceRoot: '', // within the tree, workspaceRoot is the root
+            });
+        }
+        const releaseVersion = new ReleaseVersion({
+            version: rawVersion,
+            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)}`;
+        }
+        output_1.output.log({
+            title: logTitle,
+        });
+        const githubRepoSlug = config.createRelease === 'github'
+            ? (0, github_1.getGitHubRepoSlug)(gitRemote)
+            : undefined;
+        let contents = await changelogRenderer({
+            commits,
+            releaseVersion: releaseVersion.rawVersion,
+            project: null,
+            repoSlug: githubRepoSlug,
+            entryWhenNoChanges: typeof config.entryWhenNoChanges === 'string'
+                ? (0, utils_1.interpolate)(config.entryWhenNoChanges, {
+                    projectName: project.name,
+                    projectRoot: project.data.root,
+                    workspaceRoot: '', // within the tree, workspaceRoot is the root
+                })
+                : false,
+            changelogRenderOptions: config.renderOptions,
+        });
+        /**
+         * If interactive mode, make the changelog contents available for the user to modify in their editor of choice,
+         * in a similar style to git interactive rebases/merges.
+         */
+        if (interactive) {
+            const tmpDir = (0, tmp_1.dirSync)().name;
+            const changelogPath = (0, path_1.joinPathFragments)(tmpDir, 
+            // Include the tree path in the name so that it is easier to identify which changelog file is being edited
+            `PREVIEW__${interpolatedTreePath.replace(/\//g, '_')}`);
+            (0, node_fs_1.writeFileSync)(changelogPath, contents);
+            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.read(interpolatedTreePath)?.toString() ?? '';
+            if (changelogContents) {
+                // NOTE: right now existing releases are always expected to be in markdown format, but in the future we could potentially support others via a custom parser option
+                const changelogReleases = (0, markdown_1.parseChangelogMarkdown)(changelogContents).releases;
+                const existingVersionToUpdate = changelogReleases.find((r) => r.version === releaseVersion.rawVersion);
+                if (existingVersionToUpdate) {
+                    changelogContents = changelogContents.replace(`## ${releaseVersion.rawVersion}\n\n\n${existingVersionToUpdate.body}`, contents);
+                }
+                else {
+                    // No existing version, simply prepend the new release to the top of the file
+                    changelogContents = `${contents}\n\n${changelogContents}`;
+                }
+            }
+            else {
+                // No existing changelog contents, simply create a new one using the generated contents
+                changelogContents = contents;
+            }
+            tree.write(interpolatedTreePath, changelogContents);
+            printSummary = () => (0, print_changes_1.printChanges)(tree, !!dryRun, 3, false, 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();
+            };
+            if (!dryRun) {
+                await (0, github_1.createOrUpdateGithubRelease)(githubRequestConfig, {
+                    version: releaseVersion.gitTag,
+                    prerelease: releaseVersion.isPrerelease,
+                    body: contents,
+                }, existingGithubReleaseForVersion);
+            }
+        }
+        printSummary();
     }
-    return markdown;
-}
-function isPrerelease(version) {
-    // prerelease returns an array of matching prerelease "components", or null if the version is not a prerelease
-    return (0, semver_1.prerelease)(version) !== null;
 }

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

@@ -14,11 +14,9 @@ export type ChangelogOptions = NxReleaseArgs & {
     version: string;
     to: string;
     from?: string;
-    interactive?: boolean;
+    interactive?: string;
     gitRemote?: string;
     tagVersionPrefix?: string;
-    createRelease?: string;
-    file?: string | false;
 };
 export type PublishOptions = NxReleaseArgs & RunManyOptions & {
     registry?: string;

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

@@ -91,7 +91,9 @@ const changelogCommand = {
     })
         .option('interactive', {
         alias: 'i',
-        type: 'boolean',
+        type: 'string',
+        description: 'Interactively modify changelog markdown contents in your code editor before applying the changes. You can set it to be interactive for all changelogs, or only the workspace level, or only the project level',
+        choices: ['all', 'workspace', 'projects'],
     })
         .option('gitRemote', {
         type: 'string',
@@ -102,22 +104,6 @@ const changelogCommand = {
         type: 'string',
         description: 'Prefix to apply to the version when creating the Github release tag',
         default: 'v',
-    })
-        .option('createRelease', {
-        describe: 'Create a release for the given version on a supported source control service provider, such as Github.',
-        type: 'string',
-        choices: ['github'],
-    })
-        .option('file', {
-        type: 'string',
-        description: 'The name of the file to write the changelog to. It can also be set to `false` to disable file generation. Defaults to CHANGELOG.md.',
-        default: 'CHANGELOG.md',
-        coerce: (file) => {
-            if (file === 'false') {
-                return false;
-            }
-            return file;
-        },
     })
         .check((argv) => {
         if (!argv.version) {

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

@@ -34,7 +34,7 @@ export declare const CATCH_ALL_RELEASE_GROUP = "__default__";
  * pattern such as directories and globs).
  */
 export type NxReleaseConfig = DeepRequired<NxJsonConfiguration['release'] & {
-    groups: EnsureProjectsArray<NxJsonConfiguration['release']['groups']>;
+    groups: DeepRequired<EnsureProjectsArray<NxJsonConfiguration['release']['groups']>>;
 }>;
 export interface CreateNxReleaseConfigError {
     code: 'RELEASE_GROUP_MATCHES_NO_PROJECTS' | 'PROJECT_MATCHES_MULTIPLE_GROUPS' | 'PROJECTS_MISSING_TARGET';