nx 20.7.1 → 20.8.0-beta.0

package/src/command-line/release/utils/shared-legacy.d.ts

@@ -0,0 +1,25 @@
+import { Tree } from '../../../generators/tree';
+export type ReleaseVersionGeneratorResult = {
+    data: VersionData;
+    callback: (tree: Tree, opts: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        generatorOptions?: Record<string, unknown>;
+    }) => Promise<string[] | {
+        changedFiles: string[];
+        deletedFiles: string[];
+    }>;
+};
+export type VersionData = Record<string, {
+    /**
+     * newVersion will be null in the case that no changes are detected for the project,
+     * e.g. when using conventional commits
+     */
+    newVersion: string | null;
+    currentVersion: string;
+    /**
+     * The list of projects which depend upon the current project.
+     * NOTE: This is more strictly typed in versioning v2.
+     */
+    dependentProjects: any[];
+}>;

package/src/command-line/release/utils/shared-legacy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,32 +1,26 @@
 import { ProjectGraph } from '../../../config/project-graph';
-import { Tree } from '../../../generators/tree';
 import type { ReleaseGroupWithName } from '../config/filter-release-groups';
 import { GitCommit } from './git';
 export declare const noDiffInChangelogMessage: string;
-export type ReleaseVersionGeneratorResult = {
-    data: VersionData;
-    callback: (tree: Tree, opts: {
-        dryRun?: boolean;
-        verbose?: boolean;
-        generatorOptions?: Record<string, unknown>;
-    }) => Promise<string[] | {
-        changedFiles: string[];
-        deletedFiles: string[];
-    }>;
-};
-export type VersionData = Record<string, {
+export type VersionData = Record<string, VersionDataEntry>;
+export interface VersionDataEntry {
+    currentVersion: string;
     /**
      * newVersion will be null in the case that no changes are detected for the project,
      * e.g. when using conventional commits
      */
     newVersion: string | null;
-    currentVersion: string;
     /**
      * The list of projects which depend upon the current project.
-     * TODO: investigate generic type for this once more ecosystems are explored
      */
-    dependentProjects: any[];
-}>;
+    dependentProjects: {
+        source: string;
+        target: string;
+        type: string;
+        dependencyCollection: string;
+        rawVersionSpec: string;
+    }[];
+}
 export declare class ReleaseVersion {
     rawVersion: string;
     gitTag: string;

package/src/command-line/release/version/derive-specifier-from-conventional-commits.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectGraph, ProjectGraphProjectNode } from '../../../config/project-graph';
+import { NxReleaseConfig } from '../config/config';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { getLatestGitTagForPattern } from '../utils/git';
+import { ProjectLogger } from './project-logger';
+import { SemverBumpType } from './version-actions';
+export declare function deriveSpecifierFromConventionalCommits(nxReleaseConfig: NxReleaseConfig, projectGraph: ProjectGraph, projectLogger: ProjectLogger, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, isPrerelease: boolean, latestMatchingGitTag: Awaited<ReturnType<typeof getLatestGitTagForPattern>> | undefined, fallbackCurrentVersionResolver?: 'disk', preid?: string): Promise<SemverBumpType>;

package/src/command-line/release/version/derive-specifier-from-conventional-commits.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSpecifierFromConventionalCommits = deriveSpecifierFromConventionalCommits;
+const git_1 = require("../utils/git");
+const resolve_semver_specifier_1 = require("../utils/resolve-semver-specifier");
+async function deriveSpecifierFromConventionalCommits(nxReleaseConfig, projectGraph, projectLogger, releaseGroup, projectGraphNode, 
+// NOTE: This TODO was carried over from the original version generator.
+//
+// TODO: reevaluate this prerelease logic/workflow for independent projects
+// Always assume that if the current version is a prerelease, then the next version should be a prerelease.
+// Users must manually graduate from a prerelease to a release by providing an explicit specifier.
+isPrerelease, latestMatchingGitTag, fallbackCurrentVersionResolver, preid) {
+    const affectedProjects = releaseGroup.projectsRelationship === 'independent'
+        ? [projectGraphNode.name]
+        : releaseGroup.projects;
+    // latestMatchingGitTag will be undefined if the current version was resolved from the disk fallback.
+    // In this case, we want to use the first commit as the ref to be consistent with the changelog command.
+    const previousVersionRef = latestMatchingGitTag
+        ? latestMatchingGitTag.tag
+        : fallbackCurrentVersionResolver === 'disk'
+            ? await (0, git_1.getFirstGitCommit)()
+            : undefined;
+    if (!previousVersionRef) {
+        // This should never happen since the checks above should catch if the current version couldn't be resolved
+        throw new Error(`Unable to determine previous version ref for the projects ${affectedProjects.join(', ')}. This is likely a bug in Nx.`);
+    }
+    let specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, projectGraph, affectedProjects, nxReleaseConfig.conventionalCommits);
+    if (!specifier) {
+        projectLogger.buffer(`🚫 No changes were detected using git history and the conventional commits standard`);
+        return 'none';
+    }
+    // NOTE: This TODO was carried over from the original version generator.
+    // TODO: reevaluate this prerelease logic/workflow for independent projects
+    if (isPrerelease) {
+        specifier = 'prerelease';
+        projectLogger.buffer(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease`);
+    }
+    else {
+        let extraText = '';
+        if (preid && !specifier.startsWith('pre')) {
+            specifier = `pre${specifier}`;
+            extraText = `, combined with your given preid "${preid}"`;
+        }
+        projectLogger.buffer(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard${extraText}`);
+    }
+    return specifier;
+}

package/src/command-line/release/version/deriver-specifier-from-version-plans.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectGraphProjectNode } from '../../../config/project-graph';
+import { ReleaseGroupWithName } from '../config/filter-release-groups';
+import { SemverBumpType } from './version-actions';
+import { ProjectLogger } from './project-logger';
+export declare function deriveSpecifierFromVersionPlan(projectLogger: ProjectLogger, releaseGroup: ReleaseGroupWithName, projectGraphNode: ProjectGraphProjectNode, currentVersion: string): Promise<{
+    bumpType: SemverBumpType;
+    versionPlanPath: string;
+}>;

package/src/command-line/release/version/deriver-specifier-from-version-plans.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveSpecifierFromVersionPlan = deriveSpecifierFromVersionPlan;
+const semver_1 = require("semver");
+async function deriveSpecifierFromVersionPlan(projectLogger, releaseGroup, projectGraphNode, currentVersion) {
+    const projectName = projectGraphNode.name;
+    let bumpType = null;
+    let versionPlanPath = null;
+    if (releaseGroup.projectsRelationship === 'independent') {
+        const result = releaseGroup.resolvedVersionPlans.reduce((acc, plan) => {
+            if (!acc.spec) {
+                return {
+                    spec: plan.projectVersionBumps[projectName],
+                    path: plan.relativePath,
+                };
+            }
+            if (plan.projectVersionBumps[projectName]) {
+                const prevNewVersion = (0, semver_1.inc)(currentVersion, acc.spec);
+                const nextNewVersion = (0, semver_1.inc)(currentVersion, plan.projectVersionBumps[projectName]);
+                return (0, semver_1.gt)(nextNewVersion, prevNewVersion)
+                    ? {
+                        spec: plan.projectVersionBumps[projectName],
+                        path: plan.relativePath,
+                    }
+                    : acc;
+            }
+            return acc;
+        }, { spec: null, path: null });
+        bumpType = result.spec;
+        versionPlanPath = result.path;
+    }
+    else {
+        const result = releaseGroup.resolvedVersionPlans.reduce((acc, plan) => {
+            if (!acc.spec) {
+                return {
+                    spec: plan.groupVersionBump,
+                    path: plan.relativePath,
+                };
+            }
+            const prevNewVersion = (0, semver_1.inc)(currentVersion, acc.spec);
+            const nextNewVersion = (0, semver_1.inc)(currentVersion, plan.groupVersionBump);
+            return (0, semver_1.gt)(nextNewVersion, prevNewVersion)
+                ? {
+                    spec: plan.groupVersionBump,
+                    path: plan.relativePath,
+                }
+                : acc;
+        }, { spec: null, path: null });
+        bumpType = result.spec;
+        versionPlanPath = result.path;
+    }
+    if (!bumpType) {
+        projectLogger.buffer(`🚫 No changes were detected within version plans`);
+    }
+    return {
+        bumpType: bumpType ?? 'none',
+        versionPlanPath,
+    };
+}

package/src/command-line/release/version/project-logger.d.ts

@@ -0,0 +1,8 @@
+export declare class ProjectLogger {
+    private projectName;
+    private logs;
+    private color;
+    constructor(projectName: string);
+    buffer(msg: string): void;
+    flush(): void;
+}

package/src/command-line/release/version/project-logger.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLogger = void 0;
+const chalk = require("chalk");
+const output_1 = require("../../../utils/output");
+const colors = [
+    { instance: chalk.green, spinnerColor: 'green' },
+    { instance: chalk.greenBright, spinnerColor: 'green' },
+    { instance: chalk.red, spinnerColor: 'red' },
+    { instance: chalk.redBright, spinnerColor: 'red' },
+    { instance: chalk.cyan, spinnerColor: 'cyan' },
+    { instance: chalk.cyanBright, spinnerColor: 'cyan' },
+    { instance: chalk.yellow, spinnerColor: 'yellow' },
+    { instance: chalk.yellowBright, spinnerColor: 'yellow' },
+    { instance: chalk.magenta, spinnerColor: 'magenta' },
+    { instance: chalk.magentaBright, spinnerColor: 'magenta' },
+];
+function getColor(projectName) {
+    let code = 0;
+    for (let i = 0; i < projectName.length; ++i) {
+        code += projectName.charCodeAt(i);
+    }
+    const colorIndex = code % colors.length;
+    return colors[colorIndex];
+}
+class ProjectLogger {
+    constructor(projectName) {
+        this.projectName = projectName;
+        this.logs = [];
+        this.color = getColor(projectName);
+    }
+    buffer(msg) {
+        this.logs.push(msg);
+    }
+    flush() {
+        if (this.logs.length === 0) {
+            return;
+        }
+        output_1.output.logSingleLine(`Running release version for project: ${this.color.instance.bold(this.projectName)}`);
+        this.logs.forEach((msg) => {
+            console.log(this.color.instance.bold(this.projectName) + ' ' + msg);
+        });
+    }
+}
+exports.ProjectLogger = ProjectLogger;

package/src/command-line/release/version/release-group-processor.d.ts

@@ -0,0 +1,251 @@
+import { NxReleaseVersionV2Configuration } from '../../../config/nx-json';
+import { ProjectGraph } from '../../../config/project-graph';
+import { Tree } from '../../../generators/tree';
+import { type NxReleaseConfig } from '../config/config';
+import type { ReleaseGroupWithName } from '../config/filter-release-groups';
+import type { VersionData } from '../utils/shared';
+/**
+ * The final configuration for a project after applying release group and project level overrides,
+ * as well as default values. This will be passed to the relevant version actions implementation,
+ * and referenced throughout the versioning process.
+ */
+export interface FinalConfigForProject {
+    specifierSource: NxReleaseVersionV2Configuration['specifierSource'];
+    currentVersionResolver: NxReleaseVersionV2Configuration['currentVersionResolver'];
+    currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata'];
+    fallbackCurrentVersionResolver: NxReleaseVersionV2Configuration['fallbackCurrentVersionResolver'];
+    versionPrefix: NxReleaseVersionV2Configuration['versionPrefix'];
+    preserveLocalDependencyProtocols: NxReleaseVersionV2Configuration['preserveLocalDependencyProtocols'];
+    versionActionsOptions: NxReleaseVersionV2Configuration['versionActionsOptions'];
+    manifestRootsToUpdate: NxReleaseVersionV2Configuration['manifestRootsToUpdate'];
+}
+export declare const BUMP_TYPE_REASON_TEXT: {
+    readonly DEPENDENCY_WAS_BUMPED: ", because a dependency was bumped, ";
+    readonly USER_SPECIFIER: ", from the given specifier, ";
+    readonly PROMPTED_USER_SPECIFIER: ", from the prompted specifier, ";
+    readonly CONVENTIONAL_COMMITS: ", derived from conventional commits data, ";
+    readonly VERSION_PLANS: ", read from version plan {versionPlanPath}, ";
+    readonly DEPENDENCY_ACROSS_GROUPS_WAS_BUMPED: ", because a dependency project belonging to another release group was bumped, ";
+    readonly OTHER_PROJECT_IN_FIXED_GROUP_WAS_BUMPED_DUE_TO_DEPENDENCY: ", because of a dependency-only bump to another project in the same fixed release group, ";
+};
+interface ReleaseGroupProcessorOptions {
+    dryRun: boolean;
+    verbose: boolean;
+    firstRelease: boolean;
+    preid: string;
+    userGivenSpecifier?: string;
+    projectsToProcess?: string[];
+    /**
+     * The optional results of applying the --project or --group filters.
+     * These will be empty if there is no filtering, or contain the subset of projects or groups that
+     * are being versioned if one of the (mutually exclusive) filters is set.
+     */
+    filters: {
+        projects?: string[];
+        groups?: string[];
+    };
+}
+export declare class ReleaseGroupProcessor {
+    private tree;
+    private projectGraph;
+    private nxReleaseConfig;
+    private releaseGroups;
+    private releaseGroupToFilteredProjects;
+    private options;
+    /**
+     * Stores the relationships between release groups, including their dependencies
+     * and dependents. This is used for determining processing order and propagating
+     * version changes between related groups.
+     */
+    private groupGraph;
+    /**
+     * Tracks which release groups have already been processed to avoid
+     * processing them multiple times. Used during the group traversal.
+     */
+    private processedGroups;
+    /**
+     * Keeps track of which projects have already had their versions bumped.
+     * This is used to avoid redundant version bumping and to determine which
+     * projects need their dependencies updated.
+     */
+    private bumpedProjects;
+    /**
+     * Cache of release groups sorted in topological order to ensure dependencies
+     * are processed before dependents. Computed once and reused throughout processing.
+     */
+    private sortedReleaseGroups;
+    /**
+     * Maps each release group to its projects sorted in topological order.
+     * Ensures projects are processed after their dependencies within each group.
+     */
+    private sortedProjects;
+    /**
+     * Track the unique afterAllProjectsVersioned functions involved in the current versioning process,
+     * so that we can ensure they are only invoked once per versioning execution.
+     */
+    private uniqueAfterAllProjectsVersioned;
+    /**
+     * Track the versionActions for each project so that we can invoke certain instance methods.
+     */
+    private projectsToVersionActions;
+    /**
+     * versionData that will ultimately be returned to the nx release version handler by getVersionData()
+     */
+    private versionData;
+    /**
+     * Set of all projects that are configured in the nx release config.
+     * Used to validate dependencies and identify projects that should be updated.
+     */
+    private allProjectsConfiguredForNxRelease;
+    /**
+     * Set of projects that will be processed in the current run.
+     * This is potentially a subset of allProjectsConfiguredForNxRelease based on filters
+     * and dependency relationships.
+     */
+    private allProjectsToProcess;
+    /**
+     * If the user provided a specifier at the time of versioning we store it here so that it can take priority
+     * over any configuration.
+     */
+    private userGivenSpecifier;
+    /**
+     * Caches the current version of each project to avoid repeated disk/registry/git tag lookups.
+     * Often used during new version calculation. Will be null if the current version resolver is set to 'none'.
+     */
+    private cachedCurrentVersions;
+    /**
+     * Caches git tag information for projects that resolve their version from git tags.
+     * This avoids performing expensive git operations multiple times for the same project.
+     */
+    private cachedLatestMatchingGitTag;
+    /**
+     * Temporary storage for dependent project names while building the dependency graph.
+     * This is used as an intermediate step before creating the full dependent projects data.
+     */
+    private tmpCachedDependentProjects;
+    /**
+     * Resolve the data regarding dependent projects for each project upfront so that it remains accurate
+     * even after updates are applied to manifests.
+     */
+    private originalDependentProjectsPerProject;
+    /**
+     * In the case of fixed release groups that are configured to resolve the current version from a registry
+     * or a git tag, it would be a waste of time and resources to resolve the current version for each individual
+     * project, therefore we maintain a cache of the current version for each applicable fixed release group here.
+     */
+    private currentVersionsPerFixedReleaseGroup;
+    /**
+     * Cache of project loggers for each project.
+     */
+    private projectLoggers;
+    /**
+     * Track any version plan files that have been processed so that we can delete them after versioning is complete,
+     * while leaving any unprocessed files in place.
+     */
+    private processedVersionPlanFiles;
+    /**
+     * Certain configuration options can be overridden at the project level, and otherwise fall back to the release group level.
+     * Many also have a specific default value if nothing is set at either level. To avoid applying this hierarchy for each project
+     * every time such a configuration option is needed, we cache the result per project here.
+     */
+    private finalConfigsByProject;
+    /**
+     * Maps each project to its release group for quick O(1) lookups.
+     * This avoids having to scan through all release groups to find a project.
+     */
+    private projectToReleaseGroup;
+    /**
+     * Maps each project to its dependents (projects that depend on it).
+     * This is the inverse of the projectToDependencies map and enables
+     * efficient lookup of dependent projects for propagating version changes.
+     */
+    private projectToDependents;
+    /**
+     * Maps each project to its dependencies (projects it depends on).
+     * Used for building dependency graphs and determining processing order.
+     */
+    private projectToDependencies;
+    /**
+     * Caches the updateDependents setting for each project to avoid repeated
+     * lookups and calculations. This determines if dependent projects should
+     * be automatically updated when a dependency changes.
+     */
+    private projectToUpdateDependentsSetting;
+    constructor(tree: Tree, projectGraph: ProjectGraph, nxReleaseConfig: NxReleaseConfig, releaseGroups: ReleaseGroupWithName[], releaseGroupToFilteredProjects: Map<ReleaseGroupWithName, Set<string>>, options: ReleaseGroupProcessorOptions);
+    /**
+     * Initialize the processor by building the group graph and preparing for processing.
+     * This method must be called before processGroups().
+     */
+    init(): Promise<void>;
+    /**
+     * Setup mapping from project to release group and cache updateDependents settings
+     */
+    private setupProjectReleaseGroupMapping;
+    /**
+     * Determine which projects should be processed and resolve their version actions
+     */
+    private setupProjectsToProcess;
+    /**
+     * Find all dependents that should be processed due to dependency updates
+     */
+    private findDependentsToProcess;
+    private buildGroupDependencyGraph;
+    private populateDependentProjectsData;
+    getReleaseGroupNameForProject(projectName: string): string | null;
+    getNextGroup(): string | null;
+    processGroups(): Promise<string[]>;
+    flushAllProjectLoggers(): void;
+    deleteProcessedVersionPlanFiles(): void;
+    getVersionData(): VersionData;
+    /**
+     * Invoke the afterAllProjectsVersioned functions for each unique versionActions type.
+     * This can be useful for performing actions like updating a workspace level lock file.
+     *
+     * Because the tree has already been flushed to disk at this point, each afterAllProjectsVersioned
+     * function is responsible for returning the list of changed and deleted files that it affected.
+     *
+     * The root level `release.version.versionActionsOptions` is what is passed in here because this
+     * is a one time action for the whole workspace. Release group and project level overrides are
+     * not applicable.
+     */
+    afterAllProjectsVersioned(rootVersionActionsOptions: Record<string, unknown>): Promise<{
+        changedFiles: string[];
+        deletedFiles: string[];
+    }>;
+    private processGroup;
+    private propagateChangesToDependentGroups;
+    private bumpVersions;
+    private bumpFixedVersionGroup;
+    private bumpIndependentVersionGroup;
+    private determineVersionBumpForProject;
+    private getVersionActionsForProject;
+    private getFinalConfigForProject;
+    private getProjectLoggerForProject;
+    private getCurrentCachedVersionForProject;
+    private getCachedFinalConfigForProject;
+    /**
+     * Apply project and release group precedence and default values, as well as validate the final configuration,
+     * ready to be cached.
+     */
+    private resolveFinalConfigForProject;
+    private calculateNewVersion;
+    private updateDependenciesForProject;
+    private bumpVersionForProject;
+    private updateDependenciesForDependents;
+    private getOriginalDependentProjects;
+    private propagateChanges;
+    private getFixedReleaseGroupBumpType;
+    private determineSideEffectBump;
+    private getProjectDependents;
+    private getAllNonImplicitDependents;
+    private getNonImplicitDependentsForProject;
+    private hasAutoUpdateDependents;
+    private topologicallySortReleaseGroups;
+    private topologicallySortProjects;
+    /**
+     * Precompute project -> dependents/dependencies relationships for O(1) lookups
+     */
+    private precomputeDependencyRelationships;
+    private getProjectDependencies;
+}
+export {};