nx 17.0.0 → 17.0.2

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

@@ -10,53 +10,88 @@ exports.CATCH_ALL_RELEASE_GROUP = '__default__';
 async function createNxReleaseConfig(projectGraph, userConfig = {}, 
 // Optionally ensure that all configured projects have implemented a certain target
 requiredTargetName) {
-    const DEFAULT_VERSION_GENERATOR = '@nx/js:release-version';
-    const DEFAULT_VERSION_GENERATOR_OPTIONS = {};
-    const allProjects = (0, find_matching_projects_1.findMatchingProjects)(['*'], projectGraph.nodes);
-    const userSpecifiedGroups = userConfig.groups || {};
+    const WORKSPACE_DEFAULTS = {
+        version: {
+            generator: '@nx/js:release-version',
+            generatorOptions: {},
+        },
+        changelog: {
+            workspaceChangelog: {
+                createRelease: false,
+                entryWhenNoChanges: 'This was a version bump only, there were no code changes.',
+                file: '{workspaceRoot}/CHANGELOG.md',
+                renderer: 'nx/changelog-renderer',
+                renderOptions: {
+                    includeAuthors: true,
+                },
+            },
+            // For projectChangelogs if the user has set any changelog config at all, then use one set of defaults, otherwise default to false for the whole feature
+            projectChangelogs: userConfig.changelog?.projectChangelogs
+                ? {
+                    createRelease: false,
+                    file: '{projectRoot}/CHANGELOG.md',
+                    entryWhenNoChanges: 'This was a version bump only for {projectName} to align it with other projects, there were no code changes.',
+                    renderer: 'nx/changelog-renderer',
+                    renderOptions: {
+                        includeAuthors: true,
+                    },
+                }
+                : false,
+        },
+        releaseTagPattern: 'v{version}',
+    };
+    const GROUP_DEFAULTS = {
+        version: {
+            generator: '@nx/js:release-version',
+            generatorOptions: {},
+        },
+        changelog: {
+            createRelease: false,
+            entryWhenNoChanges: 'This was a version bump only for {projectName} to align it with other projects, there were no code changes.',
+            file: '{projectRoot}/CHANGELOG.md',
+            renderer: 'nx/changelog-renderer',
+            renderOptions: {
+                includeAuthors: true,
+            },
+        },
+        releaseTagPattern: '{projectName}@v{version}',
+    };
     /**
-     * No user specified release groups, so we treat all projects as being in one release group
-     * together in which all projects are released in lock step.
+     * We first process root level config and apply defaults, so that we know how to handle the group level
+     * overrides, if applicable.
      */
-    if (Object.keys(userSpecifiedGroups).length === 0) {
-        // Ensure all projects have the relevant target available, if applicable
-        if (requiredTargetName) {
-            const error = ensureProjectsHaveTarget(allProjects, projectGraph, requiredTargetName);
-            if (error) {
-                return {
-                    error,
-                    nxReleaseConfig: null,
-                };
-            }
-        }
-        return {
-            error: null,
-            nxReleaseConfig: {
-                groups: {
-                    [exports.CATCH_ALL_RELEASE_GROUP]: {
-                        projects: allProjects,
-                        version: {
-                            generator: DEFAULT_VERSION_GENERATOR,
-                            generatorOptions: DEFAULT_VERSION_GENERATOR_OPTIONS,
-                        },
-                    },
+    const rootVersionConfig = deepMergeDefaults([WORKSPACE_DEFAULTS.version], userConfig.version);
+    const rootChangelogConfig = deepMergeDefaults([WORKSPACE_DEFAULTS.changelog], userConfig.changelog);
+    const allProjects = (0, find_matching_projects_1.findMatchingProjects)(['*'], projectGraph.nodes);
+    const groups = userConfig.groups && Object.keys(userConfig.groups).length
+        ? ensureProjectsConfigIsArray(userConfig.groups)
+        : /**
+           * No user specified release groups, so we treat all projects as being in one release group
+           * together in which all projects are released in lock step.
+           */
+            {
+                [exports.CATCH_ALL_RELEASE_GROUP]: {
+                    projects: allProjects,
+                    /**
+                     * For properties which are overriding config at the root, we use the root level config as the
+                     * default values to merge with so that the group that matches a specific project will always
+                     * be the valid source of truth for that type of config.
+                     */
+                    version: deepMergeDefaults([GROUP_DEFAULTS.version], rootVersionConfig),
+                    releaseTagPattern: GROUP_DEFAULTS.releaseTagPattern,
+                    // Directly inherit the root level config for projectChangelogs, if set
+                    changelog: rootChangelogConfig.projectChangelogs || false,
                 },
-            },
-        };
-    }
+            };
     /**
-     * The user has specified at least one release group.
-     *
      * Resolve all the project names into their release groups, and check
      * that individual projects are not found in multiple groups.
      */
     const releaseGroups = {};
     const alreadyMatchedProjects = new Set();
-    for (const [releaseGroupName, userSpecifiedGroup] of Object.entries(userSpecifiedGroups)) {
-        // Ensure that the user config for the release group can resolve at least one project
-        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(Array.isArray(userSpecifiedGroup.projects)
-            ? userSpecifiedGroup.projects
-            : [userSpecifiedGroup.projects], projectGraph.nodes);
+    for (const [releaseGroupName, releaseGroup] of Object.entries(groups)) {
+        // Ensure that the config for the release group can resolve at least one project
+        const matchingProjects = (0, find_matching_projects_1.findMatchingProjects)(releaseGroup.projects, projectGraph.nodes);
         if (!matchingProjects.length) {
             return {
                 error: {
@@ -92,25 +127,35 @@ requiredTargetName) {
             }
             alreadyMatchedProjects.add(project);
         }
-        releaseGroups[releaseGroupName] = {
+        // First apply any group level defaults, then apply actual root level config (if applicable), then group level config
+        const groupChangelogDefaults = [GROUP_DEFAULTS.changelog];
+        if (rootChangelogConfig.projectChangelogs) {
+            groupChangelogDefaults.push(rootChangelogConfig.projectChangelogs);
+        }
+        const groupDefaults = {
             projects: matchingProjects,
-            version: userSpecifiedGroup.version
-                ? {
-                    generator: userSpecifiedGroup.version.generator || DEFAULT_VERSION_GENERATOR,
-                    generatorOptions: userSpecifiedGroup.version.generatorOptions ||
-                        DEFAULT_VERSION_GENERATOR_OPTIONS,
-                }
-                : {
-                    generator: DEFAULT_VERSION_GENERATOR,
-                    generatorOptions: DEFAULT_VERSION_GENERATOR_OPTIONS,
-                },
+            version: deepMergeDefaults(
+            // First apply any group level defaults, then apply actual root level config, then group level config
+            [GROUP_DEFAULTS.version, rootVersionConfig], releaseGroup.version),
+            // If the user has set any changelog config at all, including at the root level, then use one set of defaults, otherwise default to false for the whole feature
+            changelog: releaseGroup.changelog || rootChangelogConfig.projectChangelogs
+                ? deepMergeDefaults(groupChangelogDefaults, releaseGroup.changelog || {})
+                : false,
+            releaseTagPattern: GROUP_DEFAULTS.releaseTagPattern,
         };
+        releaseGroups[releaseGroupName] = deepMergeDefaults([groupDefaults], {
+            ...releaseGroup,
+            // Ensure that the resolved project names take priority over the original user config (which could have contained unresolved globs etc)
+            projects: matchingProjects,
+        });
     }
     return {
         error: null,
         nxReleaseConfig: {
-            ...userConfig,
+            version: rootVersionConfig,
+            changelog: rootChangelogConfig,
             groups: releaseGroups,
+            releaseTagPattern: userConfig.releaseTagPattern || WORKSPACE_DEFAULTS.releaseTagPattern,
         },
     };
 }
@@ -155,6 +200,18 @@ async function handleNxReleaseConfigError(error) {
     process.exit(1);
 }
 exports.handleNxReleaseConfigError = handleNxReleaseConfigError;
+function ensureProjectsConfigIsArray(groups) {
+    const result = {};
+    for (const [groupName, groupConfig] of Object.entries(groups)) {
+        result[groupName] = {
+            ...groupConfig,
+            projects: Array.isArray(groupConfig.projects)
+                ? groupConfig.projects
+                : [groupConfig.projects],
+        };
+    }
+    return result;
+}
 function ensureProjectsHaveTarget(projects, projectGraph, requiredTargetName) {
     const missingTargetProjects = projects.filter((project) => !(0, project_graph_utils_1.projectHasTarget)(projectGraph.nodes[project], requiredTargetName));
     if (missingTargetProjects.length) {
@@ -168,3 +225,49 @@ function ensureProjectsHaveTarget(projects, projectGraph, requiredTargetName) {
     }
     return null;
 }
+function isObject(value) {
+    return value && typeof value === 'object' && !Array.isArray(value);
+}
+// Helper function to merge two config objects
+function mergeConfig(objA, objB) {
+    const merged = { ...objA };
+    for (const key in objB) {
+        if (objB.hasOwnProperty(key)) {
+            // If objB[key] is explicitly set to false, null or 0, respect that value
+            if (objB[key] === false || objB[key] === null || objB[key] === 0) {
+                merged[key] = objB[key];
+            }
+            // If both objA[key] and objB[key] are objects, recursively merge them
+            else if (isObject(merged[key]) && isObject(objB[key])) {
+                merged[key] = mergeConfig(merged[key], objB[key]);
+            }
+            // If objB[key] is defined, use it (this will overwrite any existing value in merged[key])
+            else if (objB[key] !== undefined) {
+                merged[key] = objB[key];
+            }
+        }
+    }
+    return merged;
+}
+/**
+ * This function takes in a strictly typed collection of all possible default values in a particular section of config,
+ * and an optional set of partial user config, and returns a single, deeply merged config object, where the user
+ * config takes priority over the defaults in all cases (only an `undefined` value in the user config will be
+ * overwritten by the defaults, all other falsey values from the user will be respected).
+ */
+function deepMergeDefaults(defaultConfigs, userConfig) {
+    let result;
+    // First merge defaultConfigs sequentially (meaning later defaults will override earlier ones)
+    for (const defaultConfig of defaultConfigs) {
+        if (!result) {
+            result = defaultConfig;
+            continue;
+        }
+        result = mergeConfig(result, defaultConfig);
+    }
+    // Finally, merge the userConfig
+    if (userConfig) {
+        result = mergeConfig(result, userConfig);
+    }
+    return result;
+}

package/src/command-line/release/utils/markdown.d.ts

@@ -1,7 +1,4 @@
-import { GitCommit } from './git';
-import { RepoSlug } from './github';
-export declare function generateMarkdown(commits: GitCommit[], releaseVersion: string, repoSlug?: RepoSlug): Promise<string>;
-export declare function parseChangelogMarkdown(contents: string, tagVersionPrefix: any): {
+export declare function parseChangelogMarkdown(contents: string): {
     releases: {
         version?: string;
         body: string;

package/src/command-line/release/utils/markdown.js

@@ -1,141 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseChangelogMarkdown = exports.generateMarkdown = void 0;
-const github_1 = require("./github");
-// axios types and values don't seem to match
-const _axios = require("axios");
-const axios = _axios;
-function formatName(name = '') {
-    return name
-        .split(' ')
-        .map((p) => p.trim())
-        .join(' ');
-}
-function groupBy(items, key) {
-    const groups = {};
-    for (const item of items) {
-        groups[item[key]] = groups[item[key]] || [];
-        groups[item[key]].push(item);
-    }
-    return groups;
-}
-function formatCommit(commit, repoSlug) {
-    let commitLine = '- ' +
-        (commit.scope ? `**${commit.scope.trim()}:** ` : '') +
-        (commit.isBreaking ? '⚠️  ' : '') +
-        commit.description;
-    if (repoSlug) {
-        commitLine += (0, github_1.formatReferences)(commit.references, repoSlug);
-    }
-    return commitLine;
-}
-// TODO: allow this to be configurable via config in a future release
-async function generateMarkdown(commits, releaseVersion, repoSlug) {
-    const typeGroups = groupBy(commits, 'type');
-    const markdown = [];
-    const breakingChanges = [];
-    const commitTypes = {
-        feat: { title: '🚀 Features' },
-        perf: { title: '🔥 Performance' },
-        fix: { title: '🩹 Fixes' },
-        refactor: { title: '💅 Refactors' },
-        docs: { title: '📖 Documentation' },
-        build: { title: '📦 Build' },
-        types: { title: '🌊 Types' },
-        chore: { title: '🏡 Chore' },
-        examples: { title: '🏀 Examples' },
-        test: { title: '✅ Tests' },
-        style: { title: '🎨 Styles' },
-        ci: { title: '🤖 CI' },
-    };
-    // Version Title
-    markdown.push('', `## ${releaseVersion}`, '');
-    for (const type of Object.keys(commitTypes)) {
-        const group = typeGroups[type];
-        if (!group || group.length === 0) {
-            continue;
-        }
-        markdown.push('', '### ' + commitTypes[type].title, '');
-        /**
-         * In order to make the final changelog most readable, we organize commits as follows:
-         * - By scope, where scopes are in alphabetical order (commits with no scope are listed first)
-         * - Within a particular scope grouping, we list commits in chronological order
-         */
-        const commitsInChronologicalOrder = group.reverse();
-        const commitsGroupedByScope = groupBy(commitsInChronologicalOrder, 'scope');
-        const scopesSortedAlphabetically = Object.keys(commitsGroupedByScope).sort();
-        for (const scope of scopesSortedAlphabetically) {
-            const commits = commitsGroupedByScope[scope];
-            for (const commit of commits) {
-                const line = formatCommit(commit, repoSlug);
-                markdown.push(line);
-                if (commit.isBreaking) {
-                    breakingChanges.push(line);
-                }
-            }
-        }
-    }
-    if (breakingChanges.length > 0) {
-        markdown.push('', '#### ⚠️  Breaking Changes', '', ...breakingChanges);
-    }
-    const _authors = new Map();
-    for (const commit of commits) {
-        if (!commit.author) {
-            continue;
-        }
-        const name = formatName(commit.author.name);
-        if (!name || name.includes('[bot]')) {
-            continue;
-        }
-        if (_authors.has(name)) {
-            const entry = _authors.get(name);
-            entry.email.add(commit.author.email);
-        }
-        else {
-            _authors.set(name, { email: new Set([commit.author.email]) });
-        }
-    }
-    // Try to map authors to github usernames
-    if (repoSlug) {
-        await Promise.all([..._authors.keys()].map(async (authorName) => {
-            const meta = _authors.get(authorName);
-            for (const email of meta.email) {
-                // For these pseudo-anonymized emails we can just extract the Github username from before the @
-                if (email.endsWith('@users.noreply.github.com')) {
-                    meta.github = email.split('@')[0];
-                    break;
-                }
-                // Look up any other emails against the ungh.cc API
-                const { data } = await axios
-                    .get(`https://ungh.cc/users/find/${email}`)
-                    .catch(() => ({ data: { user: null } }));
-                if (data?.user) {
-                    meta.github = data.user.username;
-                    break;
-                }
-            }
-        }));
-    }
-    const authors = [..._authors.entries()].map((e) => ({ name: e[0], ...e[1] }));
-    if (authors.length > 0) {
-        markdown.push('', '### ' + '❤️  Thank You', '', ...authors
-            // Sort the contributors by name
-            .sort((a, b) => a.name.localeCompare(b.name))
-            .map((i) => {
-            // Tag the author's Github username if we were able to resolve it so that Github adds them as a contributor
-            const github = i.github ? ` @${i.github}` : '';
-            return `- ${i.name}${github}`;
-        }));
-    }
-    return markdown.join('\n').trim();
-}
-exports.generateMarkdown = generateMarkdown;
-function escapeRegExp(string) {
-    return string.replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
-}
-function parseChangelogMarkdown(contents, tagVersionPrefix) {
-    const escapedTagVersionPrefix = escapeRegExp(tagVersionPrefix);
-    const CHANGELOG_RELEASE_HEAD_RE = new RegExp('^#{2,}\\s+' + escapedTagVersionPrefix + '(\\d+\\.\\d+\\.\\d+)', 'gm');
+exports.parseChangelogMarkdown = void 0;
+function parseChangelogMarkdown(contents) {
+    const CHANGELOG_RELEASE_HEAD_RE = new RegExp('^#{2,}\\s+(\\d+\\.\\d+\\.\\d+)', 'gm');
     const headings = [...contents.matchAll(CHANGELOG_RELEASE_HEAD_RE)];
     const releases = [];
     for (let i = 0; i < headings.length; i++) {

package/src/command-line/release/utils/print-changes.d.ts

@@ -1,3 +1,7 @@
+/// <reference types="node" />
 import { Tree } from '../../../generators/tree';
 export declare function printDiff(before: string, after: string, contextLines?: number, noDiffMessage?: string): void;
-export declare function printChanges(tree: Tree, isDryRun: boolean, diffContextLines?: number, shouldPrintDryRunMessage?: boolean, noDiffMessage?: string): void;
+export declare function printChanges(tree: Tree, isDryRun: boolean, diffContextLines?: number, shouldPrintDryRunMessage?: boolean, noDiffMessage?: string, changePredicate?: (f: {
+    path: string;
+    content?: Buffer;
+}) => boolean): void;

package/src/command-line/release/utils/print-changes.js

@@ -27,7 +27,8 @@ function printDiff(before, after, contextLines = 1, noDiffMessage = NO_DIFF_MESS
     console.log('');
 }
 exports.printDiff = printDiff;
-function printChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMessage = true, noDiffMessage) {
+function printChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMessage = true, noDiffMessage, changePredicate) {
+    changePredicate = changePredicate || (() => true);
     const changes = tree.listChanges();
     console.log('');
     if (changes.length === 0 && noDiffMessage) {
@@ -35,7 +36,7 @@ function printChanges(tree, isDryRun, diffContextLines = 1, shouldPrintDryRunMes
         return;
     }
     // Print the changes
-    changes.forEach((f) => {
+    changes.filter(changePredicate).forEach((f) => {
         if (f.type === 'CREATE') {
             console.error(`${chalk.green('CREATE')} ${f.path}${isDryRun ? chalk.keyword('orange')(' [dry-run]') : ''}`);
             printDiff('', f.content?.toString() || '', diffContextLines, noDiffMessage);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.showProjectHandler = exports.showProjectsHandler = void 0;
+const output_1 = require("../../utils/output");
 const nx_json_1 = require("../../config/nx-json");
 const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
 const file_utils_1 = require("../../project-graph/file-utils");
@@ -55,6 +56,7 @@ async function showProjectsHandler(args) {
             console.log(project);
         }
     }
+    await output_1.output.drain();
     process.exit(0);
 }
 exports.showProjectsHandler = showProjectsHandler;

package/src/config/nx-json.d.ts

@@ -1,3 +1,4 @@
+import type { ChangelogRenderOptions } from '../../changelog-renderer';
 import { PackageManager } from '../utils/package-manager';
 import { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
 export type ImplicitDependencyEntry<T = '*' | string[]> = {
@@ -37,6 +38,50 @@ interface NxReleaseVersionConfiguration {
     generator?: string;
     generatorOptions?: Record<string, unknown>;
 }
+/**
+ * **ALPHA**
+ */
+export interface NxReleaseChangelogConfiguration {
+    /**
+     * Optionally create a release containing all relevant changes on a supported version control system, it
+     * is false by default.
+     *
+     * NOTE: if createRelease is set on a group of projects, it will cause the default releaseTagPattern of
+     * "{projectName}@v{version}" to be used for those projects, even when versioning everything together.
+     */
+    createRelease?: 'github' | false;
+    /**
+     * This can either be set to a string value that will be written to the changelog file(s)
+     * at the workspace root and/or within project directories, or set to `false` to specify
+     * that no changelog entry should be made when there are no code changes.
+     *
+     * NOTE: The string value has a sensible default value and supports interpolation of
+     * {projectName} when generating for project level changelogs.
+     *
+     * E.g. for a project level changelog you could customize the message to something like:
+     * "entryWhenNoChanges": "There were no code changes for {projectName}"
+     */
+    entryWhenNoChanges?: string | false;
+    /**
+     * This is either a workspace path where the changelog markdown file will be created and read from,
+     * or set to false to disable file creation altogether (e.g. if only using Github releases).
+     *
+     * Interpolation of {projectName}, {projectRoot} and {workspaceRoot} is supported.
+     *
+     * The defaults are:
+     * - "{workspaceRoot}/CHANGELOG.md" at the workspace level
+     * - "{projectRoot}/CHANGELOG.md" at the project level
+     */
+    file?: string | false;
+    /**
+     * A path to a valid changelog renderer function used to transform commit messages and other metadata into
+     * the final changelog (usually in markdown format). Its output can be modified using the optional `renderOptions`.
+     *
+     * By default, the renderer is set to "nx/changelog-renderer" which nx provides out of the box.
+     */
+    renderer?: string;
+    renderOptions?: ChangelogRenderOptions;
+}
 /**
  * **ALPHA**
  */
@@ -45,14 +90,46 @@ interface NxReleaseConfiguration {
      * @note: When no groups are configured at all (the default), all projects in the workspace are treated as
      * if they were in a release group together.
      */
-    groups?: Record<string, {
+    groups?: Record<string, // group name
+    {
+        /**
+         * Required list of one or more projects to include in the release group. Any single project can
+         * only be used in a maximum of one release group.
+         */
         projects: string[] | string;
         /**
-         * If no version config is provided for the group, we will assume that @nx/js:release-version
-         * is the desired generator implementation, allowing for terser config for the common case.
+         * Optionally override version configuration for this group.
          */
         version?: NxReleaseVersionConfiguration;
+        /**
+         * Optionally override project changelog configuration for this group.
+         */
+        changelog?: NxReleaseChangelogConfiguration | false;
+        /**
+         * Optionally override the git/release tag pattern to use for this group.
+         */
+        releaseTagPattern?: string;
     }>;
+    changelog?: {
+        workspaceChangelog?: NxReleaseChangelogConfiguration | false;
+        projectChangelogs?: NxReleaseChangelogConfiguration | false;
+    };
+    /**
+     * If no version config is provided, we will assume that @nx/js:release-version
+     * is the desired generator implementation, allowing for terser config for the common case.
+     */
+    version?: NxReleaseVersionConfiguration;
+    /**
+     * Optional override the git/release tag pattern to use. This field is the source of truth
+     * for changelog generation and release tagging, as well as for conventional-commits parsing.
+     *
+     * It supports interpolating the version as {version} and (if releasing independently or forcing
+     * project level version control system releases) the project name as {projectName} within the string.
+     *
+     * The default releaseTagPattern for unified releases is: "v{version}"
+     * The default releaseTagPattern for releases at the project level is: "{projectName}@v{version}"
+     */
+    releaseTagPattern?: string;
 }
 /**
  * Nx.json configuration

package/src/config/nx-json.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hasNxJson = exports.readNxJson = void 0;
-const path_1 = require("path");
 const fs_1 = require("fs");
+const path_1 = require("path");
 const fileutils_1 = require("../utils/fileutils");
 const workspace_root_1 = require("../utils/workspace-root");
 function readNxJson(root = workspace_root_1.workspaceRoot) {

package/src/config/project-graph.d.ts

@@ -24,7 +24,7 @@ export interface FileData {
  */
 export type FileDataDependency = string | [target: string, type: DependencyType] | [source: string, target: string, type: DependencyType];
 export declare function fileDataDepTarget(dep: FileDataDependency): string;
-export declare function fileDataDepType(dep: FileDataDependency): "static" | DependencyType;
+export declare function fileDataDepType(dep: FileDataDependency): DependencyType | "static";
 export interface FileMap {
     nonProjectFiles: FileData[];
     projectFileMap: ProjectFileMap;