nx 20.0.0-beta.6 → 20.0.0-beta.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.0.0-beta.6",
+  "version": "20.0.0-beta.7",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -80,16 +80,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "20.0.0-beta.6",
-    "@nx/nx-darwin-arm64": "20.0.0-beta.6",
-    "@nx/nx-linux-x64-gnu": "20.0.0-beta.6",
-    "@nx/nx-linux-x64-musl": "20.0.0-beta.6",
-    "@nx/nx-win32-x64-msvc": "20.0.0-beta.6",
-    "@nx/nx-linux-arm64-gnu": "20.0.0-beta.6",
-    "@nx/nx-linux-arm64-musl": "20.0.0-beta.6",
-    "@nx/nx-linux-arm-gnueabihf": "20.0.0-beta.6",
-    "@nx/nx-win32-arm64-msvc": "20.0.0-beta.6",
-    "@nx/nx-freebsd-x64": "20.0.0-beta.6"
+    "@nx/nx-darwin-x64": "20.0.0-beta.7",
+    "@nx/nx-darwin-arm64": "20.0.0-beta.7",
+    "@nx/nx-linux-x64-gnu": "20.0.0-beta.7",
+    "@nx/nx-linux-x64-musl": "20.0.0-beta.7",
+    "@nx/nx-win32-x64-msvc": "20.0.0-beta.7",
+    "@nx/nx-linux-arm64-gnu": "20.0.0-beta.7",
+    "@nx/nx-linux-arm64-musl": "20.0.0-beta.7",
+    "@nx/nx-linux-arm-gnueabihf": "20.0.0-beta.7",
+    "@nx/nx-win32-arm64-msvc": "20.0.0-beta.7",
+    "@nx/nx-freebsd-x64": "20.0.0-beta.7"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/release/changelog-renderer/index.d.ts

@@ -1,15 +1,13 @@
 import { ChangelogChange } from '../../src/command-line/release/changelog';
 import { NxReleaseConfig } from '../../src/command-line/release/config/config';
-import { GitCommit } from '../../src/command-line/release/utils/git';
-import { GithubRepoData, RepoSlug } from '../../src/command-line/release/utils/github';
-import type { ProjectGraph } from '../../src/config/project-graph';
+import { GithubRepoData } from '../../src/command-line/release/utils/github';
 /**
  * The ChangelogRenderOptions are specific to each ChangelogRenderer implementation, and are taken
  * from the user's nx.json configuration and passed as is into the ChangelogRenderer function.
  */
 export type ChangelogRenderOptions = Record<string, unknown>;
 /**
- * When versioning projects independently and enabling `"updateDependents": "always"`, there could
+ * When versioning projects independently and enabling `"updateDependents": "auto"`, there could
  * be additional dependency bump information that is not captured in the commit data, but that nevertheless
  * should be included in the rendered changelog.
  */
@@ -17,34 +15,6 @@ export type DependencyBump = {
     dependencyName: string;
     newVersion: string;
 };
-/**
- * A ChangelogRenderer function takes in the extracted commits and other relevant metadata
- * and returns a string, or a Promise of a string of changelog contents (usually markdown).
- *
- * @param {Object} config The configuration object for the ChangelogRenderer
- * @param {ProjectGraph} config.projectGraph The project graph for the workspace
- * @param {GitCommit[]} config.commits DEPRECATED [Use 'config.changes' instead] - The collection of extracted commits to generate a changelog for
- * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
- * @param {string} config.releaseVersion The version that is being released
- * @param {string | null} config.project The name of specific project to generate a changelog for, or `null` if the overall workspace changelog
- * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
- * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
- * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the commit data
- * @param {GithubRepoData} config.repoData Resolved data for the current GitHub repository
- */
-export type ChangelogRenderer = (config: {
-    projectGraph: ProjectGraph;
-    commits?: GitCommit[];
-    changes?: ChangelogChange[];
-    releaseVersion: string;
-    project: string | null;
-    entryWhenNoChanges: string | false;
-    changelogRenderOptions: DefaultChangelogRenderOptions;
-    dependencyBumps?: DependencyBump[];
-    repoSlug?: RepoSlug;
-    repoData?: GithubRepoData;
-    conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'] | null;
-}) => Promise<string> | string;
 /**
  * The specific options available to the default implementation of the ChangelogRenderer that nx exports
  * for the common case.
@@ -72,9 +42,61 @@ export interface DefaultChangelogRenderOptions extends ChangelogRenderOptions {
      */
     versionTitleDate?: boolean;
 }
-/**
- * The default ChangelogRenderer implementation that nx exports for the common case of generating markdown
- * from the given commits and other metadata.
- */
-declare const defaultChangelogRenderer: ChangelogRenderer;
-export default defaultChangelogRenderer;
+export default class DefaultChangelogRenderer {
+    protected changes: ChangelogChange[];
+    protected changelogEntryVersion: string;
+    protected project: string | null;
+    protected entryWhenNoChanges: string | false;
+    protected changelogRenderOptions: DefaultChangelogRenderOptions;
+    protected isVersionPlans: boolean;
+    protected dependencyBumps?: DependencyBump[];
+    protected repoData?: GithubRepoData;
+    protected conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'] | null;
+    protected relevantChanges: ChangelogChange[];
+    protected breakingChanges: string[];
+    protected additionalChangesForAuthorsSection: ChangelogChange[];
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {GithubRepoData} config.repoData Resolved data for the current GitHub repository
+     * @param {NxReleaseConfig['conventionalCommits'] | null} config.conventionalCommitsConfig The configuration for conventional commits, or null if version plans are being used
+     */
+    constructor(config: {
+        changes: ChangelogChange[];
+        changelogEntryVersion: string;
+        project: string | null;
+        entryWhenNoChanges: string | false;
+        isVersionPlans: boolean;
+        changelogRenderOptions: DefaultChangelogRenderOptions;
+        dependencyBumps?: DependencyBump[];
+        repoData?: GithubRepoData;
+        conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'] | null;
+    });
+    protected filterChanges(changes: ChangelogChange[], project: string | null): ChangelogChange[];
+    render(): Promise<string>;
+    protected preprocessChanges(): void;
+    protected shouldRenderEmptyEntry(): boolean;
+    protected renderEmptyEntry(): string;
+    protected renderVersionTitle(): string;
+    protected renderChangesByType(): string[];
+    protected hasBreakingChanges(): boolean;
+    protected renderBreakingChanges(): string[];
+    protected hasDependencyBumps(): boolean;
+    protected renderDependencyBumps(): string[];
+    protected shouldRenderAuthors(): boolean;
+    protected renderAuthors(): Promise<string[]>;
+    protected formatChange(change: ChangelogChange): string;
+    protected groupChangesByType(): Record<string, ChangelogChange[]>;
+    protected groupChangesByScope(changes: ChangelogChange[]): Record<string, ChangelogChange[]>;
+    protected extractBreakingChangeExplanation(message: string): string | null;
+    protected formatName(name?: string): string;
+}

package/release/changelog-renderer/index.js

@@ -6,182 +6,239 @@ const github_1 = require("../../src/command-line/release/utils/github");
 // axios types and values don't seem to match
 const _axios = require("axios");
 const axios = _axios;
-/**
- * The default ChangelogRenderer implementation that nx exports for the common case of generating markdown
- * from the given commits and other metadata.
- */
-const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion, project, entryWhenNoChanges, changelogRenderOptions, dependencyBumps, repoSlug, conventionalCommitsConfig, repoData, }) => {
-    const markdownLines = [];
-    // If the current range of changes contains both a commit and its revert, we strip them both from the final list. Changes from version plans are unaffected, as they have no hashes.
-    for (const change of changes) {
-        if (change.type === 'revert' && change.revertedHashes) {
-            for (const revertedHash of change.revertedHashes) {
-                const revertedCommit = changes.find((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
-                if (revertedCommit) {
-                    changes.splice(changes.indexOf(revertedCommit), 1);
-                    changes.splice(changes.indexOf(change), 1);
-                }
-            }
+class DefaultChangelogRenderer {
+    /**
+     * A ChangelogRenderer class takes in the determined changes and other relevant metadata
+     * and returns a string, or a Promise of a string of changelog contents (usually markdown).
+     *
+     * @param {Object} config The configuration object for the ChangelogRenderer
+     * @param {ChangelogChange[]} config.changes The collection of changes to show in the changelog
+     * @param {string} config.changelogEntryVersion The version for which we are rendering the current changelog entry
+     * @param {string | null} config.project The name of specific project to generate a changelog entry for, or `null` if the overall workspace changelog
+     * @param {string | false} config.entryWhenNoChanges The (already interpolated) string to use as the changelog entry when there are no changes, or `false` if no entry should be generated
+     * @param {boolean} config.isVersionPlans Whether or not Nx release version plans are the source of truth for the changelog entry
+     * @param {ChangelogRenderOptions} config.changelogRenderOptions The options specific to the ChangelogRenderer implementation
+     * @param {DependencyBump[]} config.dependencyBumps Optional list of additional dependency bumps that occurred as part of the release, outside of the change data
+     * @param {GithubRepoData} config.repoData Resolved data for the current GitHub repository
+     * @param {NxReleaseConfig['conventionalCommits'] | null} config.conventionalCommitsConfig The configuration for conventional commits, or null if version plans are being used
+     */
+    constructor(config) {
+        this.changes = this.filterChanges(config.changes, config.project);
+        this.changelogEntryVersion = config.changelogEntryVersion;
+        this.project = config.project;
+        this.entryWhenNoChanges = config.entryWhenNoChanges;
+        this.isVersionPlans = config.isVersionPlans;
+        this.changelogRenderOptions = config.changelogRenderOptions;
+        this.dependencyBumps = config.dependencyBumps;
+        this.repoData = config.repoData;
+        this.conventionalCommitsConfig = config.conventionalCommitsConfig;
+        this.relevantChanges = [];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+    }
+    filterChanges(changes, project) {
+        if (project === null) {
+            return changes;
         }
+        return changes.filter((c) => c.affectedProjects &&
+            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
     }
-    let relevantChanges = changes;
-    const breakingChanges = [];
-    // For now to keep the interface of the changelog renderer non-breaking for v19 releases we have a somewhat indirect check for whether or not we are generating a changelog for version plans
-    const isVersionPlans = !conventionalCommitsConfig;
-    // Only applicable for version plans
-    const additionalChangesForAuthorsSection = [];
-    // Provide a default configuration for version plans to allow most of the subsequent logic to work in the same way it would for conventional commits
-    // NOTE: The one exception is breaking/major changes, where we do not follow the same structure and instead only show the changes once
-    if (isVersionPlans) {
-        conventionalCommitsConfig = {
-            types: {
-                feat: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
-                fix: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix,
-            },
-        };
-        // Trim down "relevant changes" to only include non-breaking ones so that we can render them differently under version plans,
-        // but keep track of the changes for the purposes of the authors section
-        // TODO(v20): Clean this abstraction up as part of the larger overall refactor of changelog rendering
-        for (let i = 0; i < relevantChanges.length; i++) {
-            if (relevantChanges[i].isBreaking) {
-                const change = relevantChanges[i];
-                additionalChangesForAuthorsSection.push(change);
-                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
-                breakingChanges.push(line);
-                relevantChanges.splice(i, 1);
-            }
+    async render() {
+        const sections = [];
+        this.preprocessChanges();
+        if (this.shouldRenderEmptyEntry()) {
+            return this.renderEmptyEntry();
+        }
+        sections.push([this.renderVersionTitle()]);
+        const changesByType = this.renderChangesByType();
+        if (changesByType.length > 0) {
+            sections.push(changesByType);
+        }
+        if (this.hasBreakingChanges()) {
+            sections.push(this.renderBreakingChanges());
+        }
+        if (this.hasDependencyBumps()) {
+            sections.push(this.renderDependencyBumps());
         }
+        if (this.shouldRenderAuthors()) {
+            sections.push(await this.renderAuthors());
+        }
+        // Join sections with double newlines, and trim any extra whitespace
+        return sections
+            .filter((section) => section.length > 0)
+            .map((section) => section.join('\n').trim())
+            .join('\n\n')
+            .trim();
     }
-    const changeTypes = conventionalCommitsConfig.types;
-    // workspace root level changelog
-    if (project === null) {
-        // No changes for the workspace
-        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
-            if (dependencyBumps?.length) {
-                applyAdditionalDependencyBumps({
-                    markdownLines,
-                    dependencyBumps,
-                    releaseVersion,
-                    changelogRenderOptions,
-                });
-            }
-            else if (entryWhenNoChanges) {
-                markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n\n${entryWhenNoChanges}`, '');
+    preprocessChanges() {
+        this.relevantChanges = [...this.changes];
+        this.breakingChanges = [];
+        this.additionalChangesForAuthorsSection = [];
+        // Filter out reverted changes
+        for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+            const change = this.relevantChanges[i];
+            if (change.type === 'revert' && change.revertedHashes) {
+                for (const revertedHash of change.revertedHashes) {
+                    const revertedCommitIndex = this.relevantChanges.findIndex((c) => c.shortHash && revertedHash.startsWith(c.shortHash));
+                    if (revertedCommitIndex !== -1) {
+                        this.relevantChanges.splice(revertedCommitIndex, 1);
+                        this.relevantChanges.splice(i, 1);
+                        i--;
+                        break;
+                    }
+                }
             }
-            return markdownLines.join('\n').trim();
         }
-        const typeGroups = groupBy(relevantChanges, 'type');
-        markdownLines.push('', createVersionTitle(releaseVersion, changelogRenderOptions), '');
-        for (const type of Object.keys(changeTypes)) {
-            const group = typeGroups[type];
-            if (!group || group.length === 0) {
-                continue;
+        if (this.isVersionPlans) {
+            this.conventionalCommitsConfig = {
+                types: {
+                    feat: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
+                    fix: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix,
+                },
+            };
+            for (let i = this.relevantChanges.length - 1; i >= 0; i--) {
+                if (this.relevantChanges[i].isBreaking) {
+                    const change = this.relevantChanges[i];
+                    this.additionalChangesForAuthorsSection.push(change);
+                    const line = this.formatChange(change);
+                    this.breakingChanges.push(line);
+                    this.relevantChanges.splice(i, 1);
+                }
             }
-            markdownLines.push('', '### ' + changeTypes[type].changelog.title, '');
-            /**
-             * In order to make the final changelog most readable, we organize changes as follows:
-             * - By scope, where scopes are in alphabetical order (changes with no scope are listed first)
-             * - Within a particular scope grouping, we list changes in chronological order
-             */
-            const changesInChronologicalOrder = group.reverse();
-            const changesGroupedByScope = groupBy(changesInChronologicalOrder, 'scope');
-            const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
-            for (const scope of scopesSortedAlphabetically) {
-                const changes = changesGroupedByScope[scope];
-                for (const change of changes) {
-                    const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
-                    markdownLines.push(line);
-                    if (change.isBreaking) {
-                        const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
-                        breakingChanges.push(breakingChangeExplanation
-                            ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
-                            : line);
-                    }
+        }
+        else {
+            for (const change of this.relevantChanges) {
+                if (change.isBreaking) {
+                    const breakingChangeExplanation = this.extractBreakingChangeExplanation(change.body);
+                    this.breakingChanges.push(breakingChangeExplanation
+                        ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                        : this.formatChange(change));
                 }
             }
         }
     }
-    else {
-        // project level changelog
-        relevantChanges = relevantChanges.filter((c) => c.affectedProjects &&
-            (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
-        // Generating for a named project, but that project has no relevant changes in the current set of commits, exit early
-        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
-            if (dependencyBumps?.length) {
-                applyAdditionalDependencyBumps({
-                    markdownLines,
-                    dependencyBumps,
-                    releaseVersion,
-                    changelogRenderOptions,
-                });
-            }
-            else if (entryWhenNoChanges) {
-                markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n\n${entryWhenNoChanges}`, '');
-            }
-            return markdownLines.join('\n').trim();
+    shouldRenderEmptyEntry() {
+        return (this.relevantChanges.length === 0 &&
+            this.breakingChanges.length === 0 &&
+            !this.hasDependencyBumps());
+    }
+    renderEmptyEntry() {
+        if (this.hasDependencyBumps()) {
+            return [
+                this.renderVersionTitle(),
+                '',
+                ...this.renderDependencyBumps(),
+            ].join('\n');
+        }
+        else if (this.entryWhenNoChanges) {
+            return `${this.renderVersionTitle()}\n\n${this.entryWhenNoChanges}`;
         }
-        markdownLines.push('', createVersionTitle(releaseVersion, changelogRenderOptions), '');
-        const typeGroups = groupBy(
-        // Sort the relevant changes to have the unscoped changes first, before grouping by type
-        relevantChanges.sort((a, b) => (b.scope ? 1 : 0) - (a.scope ? 1 : 0)), 'type');
+        return '';
+    }
+    renderVersionTitle() {
+        const isMajorVersion = `${(0, semver_1.major)(this.changelogEntryVersion)}.0.0` ===
+            this.changelogEntryVersion.replace(/^v/, '');
+        let maybeDateStr = '';
+        if (this.changelogRenderOptions.versionTitleDate) {
+            const dateStr = new Date().toISOString().slice(0, 10);
+            maybeDateStr = ` (${dateStr})`;
+        }
+        return isMajorVersion
+            ? `# ${this.changelogEntryVersion}${maybeDateStr}`
+            : `## ${this.changelogEntryVersion}${maybeDateStr}`;
+    }
+    renderChangesByType() {
+        const markdownLines = [];
+        const typeGroups = this.groupChangesByType();
+        const changeTypes = this.conventionalCommitsConfig.types;
         for (const type of Object.keys(changeTypes)) {
             const group = typeGroups[type];
             if (!group || group.length === 0) {
                 continue;
             }
             markdownLines.push('', `### ${changeTypes[type].changelog.title}`, '');
-            const changesInChronologicalOrder = group.reverse();
-            for (const change of changesInChronologicalOrder) {
-                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoData);
-                markdownLines.push(line + '\n');
-                if (change.isBreaking) {
-                    const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
-                    breakingChanges.push(breakingChangeExplanation
-                        ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
-                        : line);
+            if (this.project === null) {
+                const changesGroupedByScope = this.groupChangesByScope(group);
+                const scopesSortedAlphabetically = Object.keys(changesGroupedByScope).sort();
+                for (const scope of scopesSortedAlphabetically) {
+                    const changes = changesGroupedByScope[scope];
+                    for (const change of changes.reverse()) {
+                        const line = this.formatChange(change);
+                        markdownLines.push(line);
+                        if (change.isBreaking && !this.isVersionPlans) {
+                            const breakingChangeExplanation = this.extractBreakingChangeExplanation(change.body);
+                            this.breakingChanges.push(breakingChangeExplanation
+                                ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                                : line);
+                        }
+                    }
+                }
+            }
+            else {
+                // For project-specific changelogs, maintain the original order
+                for (const change of group) {
+                    const line = this.formatChange(change);
+                    markdownLines.push(line);
+                    if (change.isBreaking && !this.isVersionPlans) {
+                        const breakingChangeExplanation = this.extractBreakingChangeExplanation(change.body);
+                        this.breakingChanges.push(breakingChangeExplanation
+                            ? `- ${change.scope ? `**${change.scope.trim()}:** ` : ''}${breakingChangeExplanation}`
+                            : line);
+                    }
                 }
             }
         }
+        return markdownLines;
+    }
+    hasBreakingChanges() {
+        return this.breakingChanges.length > 0;
     }
-    if (breakingChanges.length > 0) {
-        markdownLines.push('', '### ⚠️  Breaking Changes', '', ...breakingChanges);
+    renderBreakingChanges() {
+        const uniqueBreakingChanges = Array.from(new Set(this.breakingChanges));
+        return ['### ⚠️  Breaking Changes', '', ...uniqueBreakingChanges];
     }
-    if (dependencyBumps?.length) {
-        applyAdditionalDependencyBumps({
-            markdownLines,
-            dependencyBumps,
-            releaseVersion,
-            changelogRenderOptions,
+    hasDependencyBumps() {
+        return this.dependencyBumps && this.dependencyBumps.length > 0;
+    }
+    renderDependencyBumps() {
+        const markdownLines = ['', '### 🧱 Updated Dependencies', ''];
+        this.dependencyBumps.forEach(({ dependencyName, newVersion }) => {
+            markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
         });
+        return markdownLines;
+    }
+    shouldRenderAuthors() {
+        return this.changelogRenderOptions.authors;
     }
-    if (changelogRenderOptions.authors) {
+    async renderAuthors() {
+        const markdownLines = [];
         const _authors = new Map();
         for (const change of [
-            ...relevantChanges,
-            ...additionalChangesForAuthorsSection,
+            ...this.relevantChanges,
+            ...this.additionalChangesForAuthorsSection,
         ]) {
-            if (!change.author) {
+            if (!change.authors) {
                 continue;
             }
-            const name = formatName(change.author.name);
-            if (!name || name.includes('[bot]')) {
-                continue;
-            }
-            if (_authors.has(name)) {
-                const entry = _authors.get(name);
-                entry.email.add(change.author.email);
-            }
-            else {
-                _authors.set(name, { email: new Set([change.author.email]) });
+            for (const author of change.authors) {
+                const name = this.formatName(author.name);
+                if (!name || name.includes('[bot]')) {
+                    continue;
+                }
+                if (_authors.has(name)) {
+                    const entry = _authors.get(name);
+                    entry.email.add(author.email);
+                }
+                else {
+                    _authors.set(name, { email: new Set([author.email]) });
+                }
             }
         }
-        // Try to map authors to github usernames
-        if (repoData && changelogRenderOptions.mapAuthorsToGitHubUsernames) {
+        if (this.repoData &&
+            this.changelogRenderOptions.mapAuthorsToGitHubUsernames) {
             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 @
-                    // It could either be in the format: username@ or github_id+username@
                     if (email.endsWith('@users.noreply.github.com')) {
                         const match = email.match(/^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
                         if (match && match[2]) {
@@ -189,7 +246,6 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
                             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 } }));
@@ -206,110 +262,78 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
         }));
         if (authors.length > 0) {
             markdownLines.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 markdownLines;
     }
-    return markdownLines.join('\n').trim();
-};
-exports.default = defaultChangelogRenderer;
-function applyAdditionalDependencyBumps({ markdownLines, dependencyBumps, releaseVersion, changelogRenderOptions, }) {
-    if (markdownLines.length === 0) {
-        markdownLines.push('', `${createVersionTitle(releaseVersion, changelogRenderOptions)}\n`, '');
-    }
-    else {
-        markdownLines.push('');
-    }
-    markdownLines.push('### 🧱 Updated Dependencies\n');
-    dependencyBumps.forEach(({ dependencyName, newVersion }) => {
-        markdownLines.push(`- Updated ${dependencyName} to ${newVersion}`);
-    });
-    markdownLines.push('');
-}
-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 formatChange(change, changelogRenderOptions, isVersionPlans, repoData) {
-    let description = change.description;
-    let extraLines = [];
-    let extraLinesStr = '';
-    if (description.includes('\n')) {
-        [description, ...extraLines] = description.split('\n');
-        // Align the extra lines with the start of the description for better readability
-        const indentation = '  ';
-        extraLinesStr = extraLines
-            .filter((l) => l.trim().length > 0)
-            .map((l) => `${indentation}${l}`)
-            .join('\n');
-    }
-    /**
-     * In version plans changelogs:
-     * - don't repeat the breaking change icon
-     * - don't render the scope
-     */
-    let changeLine = '- ' +
-        (!isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
-        (!isVersionPlans && change.scope ? `**${change.scope.trim()}:** ` : '') +
-        description;
-    if (repoData && changelogRenderOptions.commitReferences) {
-        changeLine += (0, github_1.formatReferences)(change.githubReferences, repoData);
-    }
-    if (extraLinesStr) {
-        changeLine += '\n\n' + extraLinesStr;
-    }
-    return changeLine;
-}
-/**
- * It is common to add further information about a breaking change in the commit body,
- * and it is naturally that information that should be included in the BREAKING CHANGES
- * section of changelog, rather than repeating the commit title/description.
- */
-function extractBreakingChangeExplanation(message) {
-    if (!message) {
-        return null;
+    formatChange(change) {
+        let description = change.description;
+        let extraLines = [];
+        let extraLinesStr = '';
+        if (description.includes('\n')) {
+            [description, ...extraLines] = description.split('\n');
+            const indentation = '  ';
+            extraLinesStr = extraLines
+                .filter((l) => l.trim().length > 0)
+                .map((l) => `${indentation}${l}`)
+                .join('\n');
+        }
+        let changeLine = '- ' +
+            (!this.isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
+            (!this.isVersionPlans && change.scope
+                ? `**${change.scope.trim()}:** `
+                : '') +
+            description;
+        if (this.repoData && this.changelogRenderOptions.commitReferences) {
+            changeLine += (0, github_1.formatReferences)(change.githubReferences, this.repoData);
+        }
+        if (extraLinesStr) {
+            changeLine += '\n\n' + extraLinesStr;
+        }
+        return changeLine;
     }
-    const breakingChangeIdentifier = 'BREAKING CHANGE:';
-    const startIndex = message.indexOf(breakingChangeIdentifier);
-    if (startIndex === -1) {
-        // "BREAKING CHANGE:" not found in the message
-        return null;
+    groupChangesByType() {
+        const typeGroups = {};
+        for (const change of this.relevantChanges) {
+            typeGroups[change.type] = typeGroups[change.type] || [];
+            typeGroups[change.type].push(change);
+        }
+        return typeGroups;
     }
-    const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
-    const endOfBreakingChange = message.indexOf('\n', startOfBreakingChange);
-    if (endOfBreakingChange === -1) {
-        // No newline character found, extract till the end of the message
-        return message.substring(startOfBreakingChange).trim();
+    groupChangesByScope(changes) {
+        const scopeGroups = {};
+        for (const change of changes) {
+            const scope = change.scope || '';
+            scopeGroups[scope] = scopeGroups[scope] || [];
+            scopeGroups[scope].push(change);
+        }
+        return scopeGroups;
     }
-    // Extract and return the breaking change message
-    return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
-}
-function createVersionTitle(version, changelogRenderOptions) {
-    // Normalize by removing any leading `v` during comparison
-    const isMajorVersion = `${(0, semver_1.major)(version)}.0.0` === version.replace(/^v/, '');
-    let maybeDateStr = '';
-    if (changelogRenderOptions.versionTitleDate) {
-        // YYYY-MM-DD
-        const dateStr = new Date().toISOString().slice(0, 10);
-        maybeDateStr = ` (${dateStr})`;
+    extractBreakingChangeExplanation(message) {
+        if (!message) {
+            return null;
+        }
+        const breakingChangeIdentifier = 'BREAKING CHANGE:';
+        const startIndex = message.indexOf(breakingChangeIdentifier);
+        if (startIndex === -1) {
+            return null;
+        }
+        const startOfBreakingChange = startIndex + breakingChangeIdentifier.length;
+        const endOfBreakingChange = message.indexOf('\n', startOfBreakingChange);
+        if (endOfBreakingChange === -1) {
+            return message.substring(startOfBreakingChange).trim();
+        }
+        return message.substring(startOfBreakingChange, endOfBreakingChange).trim();
     }
-    if (isMajorVersion) {
-        return `# ${version}${maybeDateStr}`;
+    formatName(name = '') {
+        return name
+            .split(' ')
+            .map((p) => p.trim())
+            .join(' ');
     }
-    return `## ${version}${maybeDateStr}`;
 }
+exports.default = DefaultChangelogRenderer;

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

@@ -103,8 +103,8 @@ async function initializePlugin(pkgName, options, nxJson) {
         if (options.__overrides_unparsed__.length) {
             args.push(...options.__overrides_unparsed__);
         }
-        await (0, child_process_2.runNxAsync)(`g ${pkgName}:${initGenerator} ${args.join(' ')}`, {
-            silent: !options.verbose,
+        (0, child_process_2.runNxSync)(`g ${pkgName}:${initGenerator} ${args.join(' ')}`, {
+            stdio: [0, 1, 2],
         });
     }
     catch (e) {

package/src/command-line/nx-commands.js

@@ -29,6 +29,7 @@ const command_object_23 = require("./login/command-object");
 const command_object_24 = require("./logout/command-object");
 const command_objects_1 = require("./deprecated/command-objects");
 const command_object_25 = require("./sync/command-object");
+const output_1 = require("../utils/output");
 // Ensure that the output takes up the available width of the terminal.
 yargs.wrap(yargs.terminalWidth());
 exports.parserConfiguration = {
@@ -82,26 +83,46 @@ exports.commandsObject = yargs
     .command(command_object_23.yargsLoginCommand)
     .command(command_object_24.yargsLogoutCommand)
     .command(resolveConformanceCommandObject())
+    .command(resolveConformanceCheckCommandObject())
     .scriptName('nx')
     .help()
     // NOTE: we handle --version in nx.ts, this just tells yargs that the option exists
     // so that it shows up in help. The default yargs implementation of --version is not
     // hit, as the implementation in nx.ts is hit first and calls process.exit(0).
     .version();
+function createMissingConformanceCommand(command) {
+    return {
+        command,
+        // Hide from --help output in the common case of not having the plugin installed
+        describe: false,
+        handler: () => {
+            output_1.output.error({
+                title: `${command} is not available`,
+                bodyLines: [
+                    `In order to use the \`nx ${command}\` command you must have an active Powerpack license and the \`@nx/powerpack-conformance\` plugin installed.`,
+                    '',
+                    'To learn more, visit https://nx.dev/features/powerpack/conformance',
+                ],
+            });
+            process.exit(1);
+        },
+    };
+}
 function resolveConformanceCommandObject() {
     try {
         const { yargsConformanceCommand } = require('@nx/powerpack-conformance');
         return yargsConformanceCommand;
     }
-    catch (e) {
-        return {
-            command: 'conformance',
-            // Hide from --help output in the common case of not having the plugin installed
-            describe: false,
-            handler: () => {
-                // TODO: Add messaging to help with learning more about powerpack and conformance
-                process.exit(1);
-            },
-        };
+    catch {
+        return createMissingConformanceCommand('conformance');
+    }
+}
+function resolveConformanceCheckCommandObject() {
+    try {
+        const { yargsConformanceCheckCommand, } = require('@nx/powerpack-conformance');
+        return yargsConformanceCheckCommand;
+    }
+    catch {
+        return createMissingConformanceCommand('conformance:check');
     }
 }

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

@@ -22,10 +22,10 @@ export interface ChangelogChange {
     body?: string;
     isBreaking?: boolean;
     githubReferences?: Reference[];
-    author?: {
+    authors?: {
         name: string;
         email: string;
-    };
+    }[];
     shortHash?: string;
     revertedHashes?: string[];
 }

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

@@ -162,7 +162,8 @@ function createAPI(overrideReleaseConfig) {
                                 body: '',
                                 isBreaking: releaseType.isBreaking,
                                 githubReferences,
-                                author,
+                                // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                                authors: [author],
                                 affectedProjects: '*',
                             }
                             : vp.triggeredByProjects.map((project) => {
@@ -173,7 +174,8 @@ function createAPI(overrideReleaseConfig) {
                                     body: '',
                                     isBreaking: releaseType.isBreaking,
                                     githubReferences,
-                                    author,
+                                    // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                                    authors: [author],
                                     affectedProjects: [project],
                                 };
                             });
@@ -209,7 +211,7 @@ function createAPI(overrideReleaseConfig) {
                     body: c.body,
                     isBreaking: c.isBreaking,
                     githubReferences: c.references,
-                    author: c.author,
+                    authors: [c.author],
                     shortHash: c.shortHash,
                     revertedHashes: c.revertedHashes,
                     affectedProjects: '*',
@@ -313,13 +315,14 @@ function createAPI(overrideReleaseConfig) {
                             }
                             const releaseType = versionPlanSemverReleaseTypeToChangelogType(bumpForProject);
                             let githubReferences = [];
-                            let author = undefined;
+                            let authors = [];
                             const parsedCommit = vp.commit
                                 ? (0, git_1.parseGitCommit)(vp.commit, true)
                                 : null;
                             if (parsedCommit) {
                                 githubReferences = parsedCommit.references;
-                                author = parsedCommit.author;
+                                // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                                authors = [parsedCommit.author];
                             }
                             return {
                                 type: releaseType.type,
@@ -329,7 +332,7 @@ function createAPI(overrideReleaseConfig) {
                                 isBreaking: releaseType.isBreaking,
                                 affectedProjects: Object.keys(vp.projectVersionBumps),
                                 githubReferences,
-                                author,
+                                authors,
                             };
                         })
                             .filter(Boolean);
@@ -365,7 +368,8 @@ function createAPI(overrideReleaseConfig) {
                             body: c.body,
                             isBreaking: c.isBreaking,
                             githubReferences: c.references,
-                            author: c.author,
+                            // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                            authors: [c.author],
                             shortHash: c.shortHash,
                             revertedHashes: c.revertedHashes,
                             affectedProjects: commitChangesNonProjectFiles(c, fileMap.nonProjectFiles)
@@ -376,15 +380,12 @@ function createAPI(overrideReleaseConfig) {
                     const projectChangelogs = await generateChangelogForProjects({
                         tree,
                         args,
-                        projectGraph,
                         changes,
                         projectsVersionData,
                         releaseGroup,
                         projects: [project],
                         nxReleaseConfig,
                         projectToAdditionalDependencyBumps,
-                        // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-                        commits: filterHiddenCommits(commits, nxReleaseConfig.conventionalCommits),
                     });
                     let hasPushed = false;
                     for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
@@ -436,7 +437,8 @@ function createAPI(overrideReleaseConfig) {
                                 body: '',
                                 isBreaking: releaseType.isBreaking,
                                 githubReferences,
-                                author,
+                                // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                                authors: [author],
                                 affectedProjects: '*',
                             }
                             : vp.triggeredByProjects.map((project) => {
@@ -447,7 +449,8 @@ function createAPI(overrideReleaseConfig) {
                                     body: '',
                                     isBreaking: releaseType.isBreaking,
                                     githubReferences,
-                                    author,
+                                    // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                                    authors: [author],
                                     affectedProjects: [project],
                                 };
                             });
@@ -482,7 +485,8 @@ function createAPI(overrideReleaseConfig) {
                         body: c.body,
                         isBreaking: c.isBreaking,
                         githubReferences: c.references,
-                        author: c.author,
+                        // TODO(JamesHenry): Implement support for Co-authored-by and adding multiple authors
+                        authors: [c.author],
                         shortHash: c.shortHash,
                         revertedHashes: c.revertedHashes,
                         affectedProjects: commitChangesNonProjectFiles(c, fileMap.nonProjectFiles)
@@ -493,15 +497,12 @@ function createAPI(overrideReleaseConfig) {
                 const projectChangelogs = await generateChangelogForProjects({
                     tree,
                     args,
-                    projectGraph,
                     changes,
                     projectsVersionData,
                     releaseGroup,
                     projects: projectNodes,
                     nxReleaseConfig,
                     projectToAdditionalDependencyBumps,
-                    // TODO: remove this after the changelog renderer is refactored to remove coupling with git commits
-                    commits: filterHiddenCommits(commits, nxReleaseConfig.conventionalCommits),
                 });
                 let hasPushed = false;
                 for (const [projectName, projectChangelog] of Object.entries(projectChangelogs)) {
@@ -716,7 +717,7 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
     const interactive = args.interactive === 'all' || args.interactive === 'workspace';
     const dryRun = !!args.dryRun;
     const gitRemote = args.gitRemote;
-    const changelogRenderer = (0, resolve_changelog_renderer_1.resolveChangelogRenderer)(config.renderer);
+    const ChangelogRendererClass = (0, resolve_changelog_renderer_1.resolveChangelogRenderer)(config.renderer);
     let interpolatedTreePath = config.file || '';
     if (interpolatedTreePath) {
         interpolatedTreePath = (0, utils_1.interpolate)(interpolatedTreePath, {
@@ -736,18 +737,17 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
         });
     }
     const githubRepoData = (0, github_1.getGitHubRepoData)(gitRemote, config.createRelease);
-    let contents = await changelogRenderer({
-        projectGraph,
+    const changelogRenderer = new ChangelogRendererClass({
         changes,
-        commits,
-        releaseVersion: releaseVersion.rawVersion,
+        changelogEntryVersion: releaseVersion.rawVersion,
         project: null,
-        repoSlug: githubRepoData?.slug,
+        isVersionPlans: false,
         repoData: githubRepoData,
         entryWhenNoChanges: config.entryWhenNoChanges,
         changelogRenderOptions: config.renderOptions,
         conventionalCommitsConfig: nxReleaseConfig.conventionalCommits,
     });
+    let contents = await changelogRenderer.render();
     /**
      * 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.
@@ -789,7 +789,7 @@ async function generateChangelogForWorkspace({ tree, args, projectGraph, nxRelea
         contents,
     };
 }
-async function generateChangelogForProjects({ tree, args, projectGraph, changes, commits, projectsVersionData, releaseGroup, projects, nxReleaseConfig, projectToAdditionalDependencyBumps, }) {
+async function generateChangelogForProjects({ tree, args, changes, projectsVersionData, releaseGroup, projects, nxReleaseConfig, projectToAdditionalDependencyBumps, }) {
     const config = releaseGroup.changelog;
     // The entire feature is disabled at the release group level, exit early
     if (config === false) {
@@ -799,7 +799,7 @@ async function generateChangelogForProjects({ tree, args, projectGraph, changes,
     const interactive = args.interactive === 'all' || args.interactive === 'projects';
     const dryRun = !!args.dryRun;
     const gitRemote = args.gitRemote;
-    const changelogRenderer = (0, resolve_changelog_renderer_1.resolveChangelogRenderer)(config.renderer);
+    const ChangelogRendererClass = (0, resolve_changelog_renderer_1.resolveChangelogRenderer)(config.renderer);
     const projectChangelogs = {};
     for (const project of projects) {
         let interpolatedTreePath = config.file || '';
@@ -829,13 +829,10 @@ async function generateChangelogForProjects({ tree, args, projectGraph, changes,
             });
         }
         const githubRepoData = (0, github_1.getGitHubRepoData)(gitRemote, config.createRelease);
-        let contents = await changelogRenderer({
-            projectGraph,
+        const changelogRenderer = new ChangelogRendererClass({
             changes,
-            commits,
-            releaseVersion: releaseVersion.rawVersion,
+            changelogEntryVersion: releaseVersion.rawVersion,
             project: project.name,
-            repoSlug: githubRepoData?.slug,
             repoData: githubRepoData,
             entryWhenNoChanges: typeof config.entryWhenNoChanges === 'string'
                 ? (0, utils_1.interpolate)(config.entryWhenNoChanges, {
@@ -845,11 +842,13 @@ async function generateChangelogForProjects({ tree, args, projectGraph, changes,
                 })
                 : false,
             changelogRenderOptions: config.renderOptions,
+            isVersionPlans: !!releaseGroup.versionPlans,
             conventionalCommitsConfig: releaseGroup.versionPlans
                 ? null
                 : nxReleaseConfig.conventionalCommits,
             dependencyBumps: projectToAdditionalDependencyBumps.get(project.name),
         });
+        let contents = await changelogRenderer.render();
         /**
          * 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.

package/src/command-line/release/utils/resolve-changelog-renderer.d.ts

@@ -1,2 +1,2 @@
-import type { ChangelogRenderer } from '../../../../release/changelog-renderer';
-export declare function resolveChangelogRenderer(changelogRendererPath: string): ChangelogRenderer;
+import type ChangelogRenderer from '../../../../release/changelog-renderer';
+export declare function resolveChangelogRenderer(changelogRendererPath: string): typeof ChangelogRenderer;

package/src/command-line/release/utils/resolve-changelog-renderer.js

@@ -10,7 +10,7 @@ function resolveChangelogRenderer(changelogRendererPath) {
         workspaceRoot: workspace_root_1.workspaceRoot,
     });
     // Try and load the provided (or default) changelog renderer
-    let changelogRenderer;
+    let ChangelogRendererClass;
     let cleanupTranspiler = () => { };
     try {
         const rootTsconfigPath = (0, typescript_1.getRootTsConfigPath)();
@@ -18,7 +18,7 @@ function resolveChangelogRenderer(changelogRendererPath) {
             cleanupTranspiler = (0, register_1.registerTsProject)(rootTsconfigPath);
         }
         const r = require(interpolatedChangelogRendererPath);
-        changelogRenderer = r.default || r;
+        ChangelogRendererClass = r.default || r;
     }
     catch (err) {
         throw err;
@@ -26,5 +26,5 @@ function resolveChangelogRenderer(changelogRendererPath) {
     finally {
         cleanupTranspiler();
     }
-    return changelogRenderer;
+    return ChangelogRendererClass;
 }

package/src/command-line/yargs-utils/shared-options.js

@@ -81,9 +81,9 @@ function withRunOptions(yargs) {
         default: false,
     })
         .option('skipSync', {
+        describe: 'Skips running the sync generators associated with the tasks.',
         type: 'boolean',
-        // TODO(leo): add description and make it visible once it is stable
-        hidden: true,
+        default: false,
     })
         .options('cloud', {
         type: 'boolean',

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

@@ -353,7 +353,8 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
         appsDir?: string;
     };
     /**
-     * Available Task Runners
+     * @deprecated Custom task runners will no longer be supported in Nx 21. Use Nx Cloud or Nx Powerpack instead.
+     * Available Task Runners for Nx to use
      */
     tasksRunnerOptions?: {
         [tasksRunnerName: string]: {

package/src/tasks-runner/cache.d.ts

@@ -1,5 +1,6 @@
 import { DefaultTasksRunnerOptions, RemoteCache } from './default-tasks-runner';
 import { Task } from '../config/task-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
 export type CachedResult = {
     terminalOutput: string;
     outputsPath: string;
@@ -10,6 +11,7 @@ export type TaskWithCachedResult = {
     task: Task;
     cachedResult: CachedResult;
 };
+export declare function dbCacheEnabled(nxJson?: NxJsonConfiguration): boolean;
 export declare function getCache(options: DefaultTasksRunnerOptions): DbCache | Cache;
 export declare class DbCache {
     private readonly options;

package/src/tasks-runner/cache.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Cache = exports.DbCache = void 0;
+exports.dbCacheEnabled = dbCacheEnabled;
 exports.getCache = getCache;
 const workspace_root_1 = require("../utils/workspace-root");
 const path_1 = require("path");
@@ -19,11 +20,14 @@ const update_manager_1 = require("../nx-cloud/update-manager");
 const get_cloud_options_1 = require("../nx-cloud/utilities/get-cloud-options");
 const is_ci_1 = require("../utils/is-ci");
 const output_1 = require("../utils/output");
+function dbCacheEnabled(nxJson = (0, nx_json_1.readNxJson)()) {
+    return (process.env.NX_DISABLE_DB !== 'true' &&
+        (nxJson.enableDbCache === true || process.env.NX_DB_CACHE === 'true'));
+}
 // Do not change the order of these arguments as this function is used by nx cloud
 function getCache(options) {
     const nxJson = (0, nx_json_1.readNxJson)();
-    return process.env.NX_DISABLE_DB !== 'true' &&
-        (nxJson.enableDbCache === true || process.env.NX_DB_CACHE === 'true')
+    return dbCacheEnabled(nxJson)
         ? new DbCache({
             // Remove this in Nx 21
             nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson) ? options.remoteCache : null,

package/src/tasks-runner/create-task-graph.js

@@ -54,10 +54,10 @@ class ProcessTasks {
             }
         }
         this.filterDummyTasks();
-        for (const projectName of Object.keys(this.dependencies)) {
-            if (this.dependencies[projectName].length > 1) {
-                this.dependencies[projectName] = [
-                    ...new Set(this.dependencies[projectName]).values(),
+        for (const taskId of Object.keys(this.dependencies)) {
+            if (this.dependencies[taskId].length > 0) {
+                this.dependencies[taskId] = [
+                    ...new Set(this.dependencies[taskId].filter((d) => d !== taskId)).values(),
                 ];
             }
         }

package/src/tasks-runner/run-command.js

@@ -511,12 +511,21 @@ function loadTasksRunner(modulePath) {
 }
 function getRunner(nxArgs, nxJson) {
     let runner = nxArgs.runner;
-    runner = runner || 'default';
+    runner = runner ?? 'default';
     if (runner !== 'default' && !nxJson.tasksRunnerOptions?.[runner]) {
         throw new Error(`Could not find runner configuration for ${runner}`);
     }
     const modulePath = getTasksRunnerPath(runner, nxJson);
     try {
+        if (isCustomRunnerPath(modulePath)) {
+            output_1.output.warn({
+                title: `Custom task runners will no longer be supported in Nx 21.`,
+                bodyLines: [
+                    `Use Nx Cloud or the Nx Powerpack caches instead.`,
+                    `For more information, see https://nx.dev/features/powerpack/custom-caching`,
+                ],
+            });
+        }
         const tasksRunner = loadTasksRunner(modulePath);
         return {
             tasksRunner,
@@ -527,6 +536,7 @@ function getRunner(nxArgs, nxJson) {
         throw new Error(`Could not find runner configuration for ${runner}`);
     }
 }
+const defaultTasksRunnerPath = require.resolve('./default-tasks-runner');
 function getTasksRunnerPath(runner, nxJson) {
     let modulePath = nxJson.tasksRunnerOptions?.[runner]?.runner;
     if (modulePath) {
@@ -544,7 +554,7 @@ function getTasksRunnerPath(runner, nxJson) {
         process.env.NX_CLOUD_ACCESS_TOKEN ||
         // Nx Cloud ID specified in nxJson
         nxJson.nxCloudId;
-    return isCloudRunner ? 'nx-cloud' : require.resolve('./default-tasks-runner');
+    return isCloudRunner ? 'nx-cloud' : defaultTasksRunnerPath;
 }
 function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
     const defaultCacheableOperations = [];
@@ -588,3 +598,6 @@ function getRunnerOptions(runner, nxJson, nxArgs, isCloudDefault) {
     }
     return result;
 }
+function isCustomRunnerPath(modulePath) {
+    return !['nx-cloud', '@nrwl/nx-cloud', defaultTasksRunnerPath].includes(modulePath);
+}

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

@@ -7,6 +7,9 @@ export interface RawNxArgs extends NxArgs {
 export interface NxArgs {
     targets?: string[];
     configuration?: string;
+    /**
+     * @deprecated Custom task runners will no longer be supported in Nx 21. Use Nx Cloud or Nx Powerpack instead.
+     */
     runner?: string;
     parallel?: number;
     untracked?: boolean;