nx 23.1.1 → 23.1.2

package/dist/src/command-line/release/version/release-group-processor.js

@@ -31,6 +31,21 @@ class ReleaseGroupProcessor {
          * processing them multiple times. Used during the group traversal.
          */
         this.processedGroups = new Set();
+        /**
+         * Tracks release groups that have completed all version decisions. A group
+         * can reach this state before its dependency manifests are updated.
+         */
+        this.groupsWithFinalizedVersionDecisions = new Set();
+        /**
+         * Tracks projects whose dependency manifests must wait until all release
+         * groups have completed their version decisions.
+         */
+        this.projectsWithDeferredDependencyUpdates = new Set();
+        /**
+         * Indicates that every release group has completed its version decisions,
+         * so dependency manifests can use final versions safely.
+         */
+        this.allVersionDecisionsFinalized = false;
         /**
          * Keeps track of which projects have already had their versions bumped.
          * This is used to avoid redundant version bumping and to determine which
@@ -120,6 +135,7 @@ class ReleaseGroupProcessor {
             this.processedGroups.add(nextGroup);
             processOrder.push(nextGroup);
         }
+        await this.finalizeAllVersionDecisions(processOrder);
         return processOrder;
     }
     flushAllProjectLoggers() {
@@ -208,11 +224,6 @@ class ReleaseGroupProcessor {
     async processGroup(releaseGroupName) {
         const groupNode = this.releaseGraph.groupGraph.get(releaseGroupName);
         await this.bumpVersions(groupNode.group);
-        // Flush the project loggers for the group
-        for (const project of groupNode.group.projects) {
-            const projectLogger = this.getProjectLoggerForProject(project);
-            projectLogger.flush();
-        }
     }
     async bumpVersions(releaseGroup) {
         if (releaseGroup.projectsRelationship === 'fixed') {
@@ -224,6 +235,7 @@ class ReleaseGroupProcessor {
     }
     async bumpFixedVersionGroup(releaseGroup) {
         if (releaseGroup.projects.length === 0) {
+            this.finalizeVersionDecisionsForGroup(releaseGroup);
             return false;
         }
         let bumped = false;
@@ -287,6 +299,7 @@ class ReleaseGroupProcessor {
                     projectLogger.buffer(`🚫 Skipping versioning for ${project} as it is a part of a fixed release group with ${firstProject} and no dependency bumps were detected`);
                 }
             }
+            this.finalizeVersionDecisionsForGroup(releaseGroup);
             return bumpedByDependency;
         }
         const { newVersion } = await this.calculateNewVersion(firstProject, newVersionInput, newVersionInputReason, newVersionInputReasonData);
@@ -319,6 +332,7 @@ class ReleaseGroupProcessor {
                 dependentProjects: this.getOriginalDependentProjects(project),
             });
         }
+        this.finalizeVersionDecisionsForGroup(releaseGroup);
         // Then, update dependencies for all projects in the fixed group, also in topological order
         if (bumped) {
             for (const project of sortedProjects) {
@@ -359,6 +373,7 @@ class ReleaseGroupProcessor {
                 }
             }
         }
+        this.finalizeVersionDecisionsForGroup(releaseGroup);
         // Third pass: Update dependencies also in topological order
         for (const project of sortedProjects) {
             if (projectsToUpdate.has(project) &&
@@ -472,6 +487,11 @@ class ReleaseGroupProcessor {
         if (!this.releaseGraph.allProjectsToProcess.has(projectName)) {
             throw new Error(`Unable to find ${projectName} in allProjectsToProcess, please report this as a bug on https://github.com/nrwl/nx/issues`);
         }
+        if (!this.allVersionDecisionsFinalized) {
+            this.projectsWithDeferredDependencyUpdates.add(projectName);
+            return;
+        }
+        this.projectsWithDeferredDependencyUpdates.delete(projectName);
         const versionActions = this.getVersionActionsForProject(projectName);
         const cachedFinalConfigForProject = this.getCachedFinalConfigForProject(projectName);
         const dependenciesToUpdate = {};
@@ -502,11 +522,65 @@ class ReleaseGroupProcessor {
             }
         }
         const projectLogger = this.getProjectLoggerForProject(projectName);
-        const logMessages = await versionActions.updateProjectDependencies(this.tree, this.projectGraph, dependenciesToUpdate);
+        const logMessages = await versionActions.updateProjectDependencies(this.tree, this.projectGraph, dependenciesToUpdate, (dependencyProjectName) => this.resolveVersionForDependency(dependencyProjectName));
         for (const logMessage of logMessages) {
             projectLogger.buffer(logMessage);
         }
     }
+    finalizeVersionDecisionsForGroup(releaseGroup) {
+        this.groupsWithFinalizedVersionDecisions.add(releaseGroup.name);
+    }
+    async finalizeAllVersionDecisions(processOrder) {
+        const unfinalizedReleaseGroups = Array.from(this.releaseGraph.groupGraph.keys()).filter((releaseGroupName) => !this.groupsWithFinalizedVersionDecisions.has(releaseGroupName));
+        if (unfinalizedReleaseGroups.length > 0) {
+            const releaseGroupNames = unfinalizedReleaseGroups
+                .map((releaseGroupName) => `"${releaseGroupName}"`)
+                .join(', ');
+            throw new Error(`Unable to finalize version decisions for release groups ${releaseGroupNames}. Please report this as a bug on https://github.com/nrwl/nx/issues.`);
+        }
+        this.allVersionDecisionsFinalized = true;
+        for (const releaseGroupName of processOrder) {
+            const releaseGroup = this.releaseGraph.groupGraph.get(releaseGroupName);
+            for (const projectName of releaseGroup.group.projects) {
+                if (this.projectsWithDeferredDependencyUpdates.has(projectName)) {
+                    await this.updateDependenciesForProject(projectName);
+                }
+            }
+            // Keep each group's buffered output together and in processing order.
+            for (const projectName of releaseGroup.group.projects) {
+                this.getProjectLoggerForProject(projectName).flush();
+            }
+        }
+        if (this.projectsWithDeferredDependencyUpdates.size > 0) {
+            const deferredProjects = Array.from(this.projectsWithDeferredDependencyUpdates, (projectName) => `"${projectName}"`).join(', ');
+            throw new Error(`Unable to update dependencies for projects ${deferredProjects} because their release groups were not processed. Please report this as a bug on https://github.com/nrwl/nx/issues.`);
+        }
+        this.flushAllProjectLoggers();
+    }
+    /**
+     * Resolve a dependency version when `dependenciesToUpdate` does not contain
+     * a concrete version for a manifest entry.
+     *
+     * @internal
+     */
+    async resolveVersionForDependency(dependencyProjectName) {
+        const versionData = this.versionData.get(dependencyProjectName);
+        if (versionData?.newVersion) {
+            return versionData.newVersion;
+        }
+        if (!this.releaseGraph.allProjectsToProcess.has(dependencyProjectName)) {
+            return this.releaseGraph.resolveCurrentVersionForDependency(this.tree, this.projectGraph, dependencyProjectName, this.options.preid);
+        }
+        const releaseGroupName = this.getReleaseGroupNameForProject(dependencyProjectName);
+        if (!releaseGroupName ||
+            !this.groupsWithFinalizedVersionDecisions.has(releaseGroupName)) {
+            throw new Error(`Cannot resolve a concrete version for dependency project "${dependencyProjectName}" because its release group has not finalized its version decisions. Ensure the release group can finalize the dependency version before Nx Release updates the dependent manifest.`);
+        }
+        if (versionData?.currentVersion) {
+            return versionData.currentVersion;
+        }
+        throw new Error(`Cannot resolve a concrete version for dependency project "${dependencyProjectName}" because its finalized release data has no current or new version.`);
+    }
     async bumpVersionForProject(projectName, bumpType, bumpTypeReason, bumpTypeReasonData) {
         const projectLogger = this.getProjectLoggerForProject(projectName);
         if (bumpType === 'none') {

package/dist/src/command-line/release/version/version-actions.d.ts

@@ -5,6 +5,19 @@ import type { Tree } from '../../../generators/tree';
 import type { ReleaseGroupWithName } from '../config/filter-release-groups';
 import type { FinalConfigForProject } from '../utils/release-graph';
 export type SemverBumpType = ReleaseType | 'none';
+/**
+ * Lazily resolves the concrete version of a dependency project that is not
+ * already represented in `dependenciesToUpdate`.
+ *
+ * Ecosystem-specific VersionActions implementations can use this when a
+ * manifest reference requires a concrete version but `dependenciesToUpdate`
+ * does not contain one. The resolved value can be the dependency's new version
+ * when it is part of the release, or its current version when it is not being
+ * versioned.
+ *
+ * @public
+ */
+export type ResolveVersionForDependency = (dependencyProjectName: string) => Promise<string>;
 /**
  * Implementation details of performing any actions after all projects have been versioned.
  * An example might be updating a workspace level lock file.
@@ -45,6 +58,14 @@ export declare abstract class VersionActions {
      * If a manifest file is not applicable to the current versioning use-case, this should be set to null.
      */
     abstract validManifestFilenames: string[] | null;
+    /**
+     * Whether manifests updated by this implementation should be excluded from
+     * the final Prettier pass performed by Nx Release.
+     *
+     * Custom implementations must opt in explicitly. This defaults to false so
+     * their existing formatting behavior does not change.
+     */
+    excludeManifestsFromFormatting: boolean;
     /**
      * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
      * versions and dependencies are determined. If no manifest files should be updated based on the user's
@@ -170,10 +191,14 @@ export declare abstract class VersionActions {
      * with new dependency versions, but for application deployments it might involve
      * updating something else instead, it depends on the type of application.
      *
+     * `resolveVersionForDependency` is intentionally lazy: implementations
+     * decide which manifest values require a concrete version, while release core
+     * remains unaware of ecosystem-specific dependency protocols.
+     *
      * It should return an array of log messages that will be displayed unmodified to the user
      * after the dependencies have been updated.
      */
-    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+    abstract updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>, resolveVersionForDependency?: ResolveVersionForDependency): Promise<string[]>;
 }
 export declare class NOOP_VERSION_ACTIONS extends VersionActions {
     validManifestFilenames: any;
@@ -194,6 +219,6 @@ export declare class NOOP_VERSION_ACTIONS extends VersionActions {
         newVersion: string;
         logText: string;
     }>;
-    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<string[]>;
+    updateProjectDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>, resolveVersionForDependency?: ResolveVersionForDependency): Promise<string[]>;
     updateProjectVersion(tree: Tree, newVersion: string): Promise<string[]>;
 }

package/dist/src/command-line/release/version/version-actions.js

@@ -84,6 +84,14 @@ class VersionActions {
         this.releaseGroup = releaseGroup;
         this.projectGraphNode = projectGraphNode;
         this.finalConfigForProject = finalConfigForProject;
+        /**
+         * Whether manifests updated by this implementation should be excluded from
+         * the final Prettier pass performed by Nx Release.
+         *
+         * Custom implementations must opt in explicitly. This defaults to false so
+         * their existing formatting behavior does not change.
+         */
+        this.excludeManifestsFromFormatting = false;
         /**
          * The interpolated manifest paths to update, if applicable based on the user's configuration, when new
          * versions and dependencies are determined. If no manifest files should be updated based on the user's
@@ -237,7 +245,7 @@ class NOOP_VERSION_ACTIONS extends VersionActions {
             logText: 'Skipped default versioning as no-op.',
         });
     }
-    updateProjectDependencies(tree, projectGraph, dependenciesToUpdate) {
+    updateProjectDependencies(tree, projectGraph, dependenciesToUpdate, resolveVersionForDependency) {
         return Promise.resolve([]);
     }
     updateProjectVersion(tree, newVersion) {

package/dist/src/command-line/release/version.js

@@ -173,11 +173,15 @@ function createAPI(overrideReleaseConfig, ignoreNxJsonConfig) {
             // Bubble up the error so that the CLI can print the error and exit, or the programmatic API can handle it
             throw err;
         }
-        /**
-         * Ensure that formatting is applied so that version bump diffs are as minimal as possible
-         * within the context of the user's workspace.
-         */
-        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, { silent: true });
+        // A version actions implementation can opt its manifests out of this final
+        // pass when it already preserves their formatting while updating values.
+        const manifestsToExcludeFromFormatting = new Set(Array.from(releaseGraph.projectsToVersionActions.values()).flatMap((versionActions) => versionActions.excludeManifestsFromFormatting
+            ? versionActions.manifestsToUpdate.map(({ manifestPath }) => manifestPath)
+            : []));
+        await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree, {
+            silent: true,
+            excludePaths: manifestsToExcludeFromFormatting,
+        });
         printAndFlushChanges(tree, !!args.dryRun);
         const { changedFiles: changed, deletedFiles: deleted } = await processor.afterAllProjectsVersioned({
             ...nxReleaseConfig.version

package/dist/src/command-line/reset/reset.js

@@ -137,7 +137,12 @@ function cleanupCacheEntries() {
 }
 function cleanupNativeFileCache() {
     return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
-        (0, node_fs_1.rmSync)((0, native_file_cache_location_1.getNativeFileCacheLocation)(), { recursive: true, force: true });
+        // Null when the native cache root is not a real directory we own, which
+        // would mean deleting through a path another user planted.
+        const cacheDir = (0, native_file_cache_location_1.getNativeFileCacheLocationToDelete)();
+        if (cacheDir) {
+            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        }
     });
 }
 function cleanupWorkspaceData() {

package/dist/src/command-line/run/run-one.js

@@ -51,6 +51,7 @@ async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
+        await output_1.output.drain();
         process.exit(status);
     }
 }

package/dist/src/command-line/run-many/run-many.js

@@ -41,6 +41,7 @@ async function runMany(args, extraTargetDependencies = {}, extraOptions = {
     }
     else {
         const status = await (0, run_command_1.runCommand)(projects, projectGraph, { nxJson }, nxArgs, overrides, null, extraTargetDependencies, extraOptions);
+        await output_1.output.drain();
         process.exit(status);
     }
 }

package/dist/src/command-line/watch/watch.js

@@ -173,6 +173,17 @@ async function watch(args) {
             });
             process.exit(1);
         }
+        else if (err instanceof client_1.WatcherFailedError) {
+            output_1.output.error({
+                title: 'The Nx Daemon stopped watching for file changes',
+                bodyLines: [
+                    err.message,
+                    'On Linux this is usually the inotify watch limit. See https://askubuntu.com/questions/1088272/inotify-add-watch-failed-no-space-left-on-device',
+                    'Please restart your watch command.',
+                ],
+            });
+            process.exit(1);
+        }
         else if (err !== null) {
             output_1.output.error({
                 title: 'Watch error',
@@ -181,6 +192,8 @@ async function watch(args) {
                     err.message,
                 ],
             });
+            // `data` is null on the error path; falling through dereferences it.
+            return;
         }
         // Only pass the projects to the queue if the command has a replacement for projects
         if (args.command.match(projectReplacementRegex)) {