@nx/js 17.0.2 → 17.0.4

package/src/generators/release-version/release-version.js

@@ -3,112 +3,367 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseVersionGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
 const chalk = require("chalk");
-const child_process_1 = require("child_process");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const config_1 = require("nx/src/command-line/release/config/config");
+const git_1 = require("nx/src/command-line/release/utils/git");
+const resolve_semver_specifier_1 = require("nx/src/command-line/release/utils/resolve-semver-specifier");
+const semver_1 = require("nx/src/command-line/release/utils/semver");
 const version_1 = require("nx/src/command-line/release/version");
 const utils_1 = require("nx/src/tasks-runner/utils");
 const ora = require("ora");
-const path_1 = require("path");
+const semver_2 = require("semver");
+const npm_config_1 = require("../../utils/npm-config");
 const resolve_local_package_dependencies_1 = require("./utils/resolve-local-package-dependencies");
+const update_lock_file_1 = require("./utils/update-lock-file");
 async function releaseVersionGenerator(tree, options) {
-    const projects = options.projects;
-    // Resolve any custom package roots for each project upfront as they will need to be reused during dependency resolution
-    const projectNameToPackageRootMap = new Map();
-    for (const project of projects) {
-        projectNameToPackageRootMap.set(project.name, 
-        // Default to the project root if no custom packageRoot
-        !options.packageRoot
-            ? project.data.root
-            : (0, utils_1.interpolate)(options.packageRoot, {
-                workspaceRoot: '',
-                projectRoot: project.data.root,
-                projectName: project.name,
-            }));
-    }
-    let currentVersion;
-    for (const project of projects) {
-        const projectName = project.name;
-        const packageRoot = projectNameToPackageRootMap.get(projectName);
-        const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
-        const workspaceRelativePackageJsonPath = (0, path_1.relative)(devkit_1.workspaceRoot, packageJsonPath);
-        const color = getColor(projectName);
-        const log = (msg) => {
-            console.log(color.instance.bold(projectName) + ' ' + msg);
-        };
-        if (!tree.exists(packageJsonPath)) {
-            throw new Error(`The project "${projectName}" does not have a package.json available at ${workspaceRelativePackageJsonPath}.
-        
-To fix this you will either need to add a package.json file at that location, or configure "release" within your nx.json to exclude "${projectName}" from the current release group, or amend the packageRoot configuration to point to where the package.json should be.`);
+    try {
+        const versionData = {};
+        // If the user provided a specifier, validate that it is valid semver or a relative semver keyword
+        if (options.specifier) {
+            if (!(0, semver_1.isValidSemverSpecifier)(options.specifier)) {
+                throw new Error(`The given version specifier "${options.specifier}" is not valid. You provide an exact version or a valid semver keyword such as "major", "minor", "patch", etc.`);
+            }
+            // The node semver library classes a leading `v` as valid, but we want to ensure it is not present in the final version
+            options.specifier = options.specifier.replace(/^v/, '');
         }
-        devkit_1.output.logSingleLine(`Running release version for project: ${color.instance.bold(project.name)}`);
-        const projectPackageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
-        log(`🔍 Reading data for package "${projectPackageJson.name}" from ${workspaceRelativePackageJsonPath}`);
-        const { name: packageName, version: currentVersionFromDisk } = projectPackageJson;
-        switch (options.currentVersionResolver) {
-            case 'registry': {
-                const metadata = options.currentVersionResolverMetadata;
-                const registry = metadata?.registry ?? 'https://registry.npmjs.org';
-                const tag = metadata?.tag ?? 'latest';
-                // If the currentVersionResolver is set to registry, we only want to make the request once for the whole batch of projects
-                if (!currentVersion) {
-                    const spinner = ora(`${Array.from(new Array(projectName.length + 3)).join(' ')}Resolving the current version for tag "${tag}" on ${registry}`);
-                    spinner.color =
-                        color.spinnerColor;
-                    spinner.start();
-                    // Must be non-blocking async to allow spinner to render
-                    currentVersion = await new Promise((resolve, reject) => {
-                        (0, child_process_1.exec)(`npm view ${packageName} version --registry=${registry} --tag=${tag}`, (error, stdout, stderr) => {
-                            if (error) {
-                                return reject(error);
+        if (options.versionPrefix &&
+            version_1.validReleaseVersionPrefixes.indexOf(options.versionPrefix) === -1) {
+            throw new Error(`Invalid value for version.generatorOptions.versionPrefix: "${options.versionPrefix}"
+
+Valid values are: ${version_1.validReleaseVersionPrefixes
+                .map((s) => `"${s}"`)
+                .join(', ')}`);
+        }
+        if (options.firstRelease) {
+            // always use disk as a fallback for the first release
+            options.fallbackCurrentVersionResolver = 'disk';
+        }
+        const projects = options.projects;
+        const resolvePackageRoot = createResolvePackageRoot(options.packageRoot);
+        // Resolve any custom package roots for each project upfront as they will need to be reused during dependency resolution
+        const projectNameToPackageRootMap = new Map();
+        for (const project of projects) {
+            projectNameToPackageRootMap.set(project.name, resolvePackageRoot(project));
+        }
+        let currentVersion = undefined;
+        let currentVersionResolvedFromFallback = false;
+        // only used for options.currentVersionResolver === 'git-tag', but
+        // must be declared here in order to reuse it for additional projects
+        let latestMatchingGitTag = undefined;
+        // if specifier is undefined, then we haven't resolved it yet
+        // if specifier is null, then it has been resolved and no changes are necessary
+        let specifier = options.specifier
+            ? options.specifier
+            : undefined;
+        for (const project of projects) {
+            const projectName = project.name;
+            const packageRoot = projectNameToPackageRootMap.get(projectName);
+            if (!packageRoot) {
+                throw new Error(`The project "${projectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
+            }
+            const packageJsonPath = (0, node_path_1.join)(packageRoot, 'package.json');
+            const color = getColor(projectName);
+            const log = (msg) => {
+                console.log(color.instance.bold(projectName) + ' ' + msg);
+            };
+            if (!tree.exists(packageJsonPath)) {
+                throw new Error(`The project "${projectName}" does not have a package.json available at ${packageJsonPath}.
+
+To fix this you will either need to add a package.json file at that location, or configure "release" within your nx.json to exclude "${projectName}" from the current release group, or amend the packageRoot configuration to point to where the package.json should be.`);
+            }
+            devkit_1.output.logSingleLine(`Running release version for project: ${color.instance.bold(project.name)}`);
+            const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+            log(`🔍 Reading data for package "${packageJson.name}" from ${packageJsonPath}`);
+            const { name: packageName, version: currentVersionFromDisk } = packageJson;
+            switch (options.currentVersionResolver) {
+                case 'registry': {
+                    const metadata = options.currentVersionResolverMetadata;
+                    const registryArg = typeof metadata?.registry === 'string'
+                        ? metadata.registry
+                        : undefined;
+                    const tagArg = typeof metadata?.tag === 'string' ? metadata.tag : undefined;
+                    const warnFn = (message) => {
+                        console.log(chalk.keyword('orange')(message));
+                    };
+                    const { registry, tag, registryConfigKey } = await (0, npm_config_1.parseRegistryOptions)(devkit_1.workspaceRoot, {
+                        packageRoot: (0, node_path_1.join)(devkit_1.workspaceRoot, packageRoot),
+                        packageJson,
+                    }, {
+                        registry: registryArg,
+                        tag: tagArg,
+                    }, warnFn);
+                    /**
+                     * If the currentVersionResolver is set to registry, and the projects are not independent, we only want to make the request once for the whole batch of projects.
+                     * For independent projects, we need to make a request for each project individually as they will most likely have different versions.
+                     */
+                    if (!currentVersion ||
+                        options.releaseGroup.projectsRelationship === 'independent') {
+                        const spinner = ora(`${Array.from(new Array(projectName.length + 3)).join(' ')}Resolving the current version for tag "${tag}" on ${registry}`);
+                        spinner.color =
+                            color.spinnerColor;
+                        spinner.start();
+                        try {
+                            // Must be non-blocking async to allow spinner to render
+                            currentVersion = await new Promise((resolve, reject) => {
+                                (0, node_child_process_1.exec)(`npm view ${packageName} version --"${registryConfigKey}=${registry}" --tag=${tag}`, (error, stdout, stderr) => {
+                                    if (error) {
+                                        return reject(error);
+                                    }
+                                    if (stderr) {
+                                        return reject(stderr);
+                                    }
+                                    return resolve(stdout.trim());
+                                });
+                            });
+                            spinner.stop();
+                            log(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${registry}`);
+                        }
+                        catch (e) {
+                            spinner.stop();
+                            if (options.fallbackCurrentVersionResolver === 'disk') {
+                                log(`📄 Unable to resolve the current version from the registry ${registry}. Falling back to the version on disk of ${currentVersionFromDisk}`);
+                                currentVersion = currentVersionFromDisk;
+                                currentVersionResolvedFromFallback = true;
                             }
-                            if (stderr) {
-                                return reject(stderr);
+                            else {
+                                throw new Error(`Unable to resolve the current version from the registry ${registry}. Please ensure that the package exists in the registry in order to use the "registry" currentVersionResolver. Alternatively, you can use the --first-release option or set "release.version.generatorOptions.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when the registry lookup fails.`);
                             }
-                            return resolve(stdout.trim());
+                        }
+                    }
+                    else {
+                        if (currentVersionResolvedFromFallback) {
+                            log(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
+                        }
+                        else {
+                            log(`📄 Using the current version ${currentVersion} already resolved from the registry ${registry}`);
+                        }
+                    }
+                    break;
+                }
+                case 'disk':
+                    currentVersion = currentVersionFromDisk;
+                    log(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
+                    break;
+                case 'git-tag': {
+                    if (!currentVersion ||
+                        // We always need to independently resolve the current version from git tag per project if the projects are independent
+                        options.releaseGroup.projectsRelationship === 'independent') {
+                        const releaseTagPattern = options.releaseGroup.releaseTagPattern;
+                        latestMatchingGitTag = await (0, git_1.getLatestGitTagForPattern)(releaseTagPattern, {
+                            projectName: project.name,
                         });
-                    });
-                    spinner.stop();
-                    log(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${registry}`);
+                        if (!latestMatchingGitTag) {
+                            if (options.fallbackCurrentVersionResolver === 'disk') {
+                                log(`📄 Unable to resolve the current version from git tag using pattern "${releaseTagPattern}". Falling back to the version on disk of ${currentVersionFromDisk}`);
+                                currentVersion = currentVersionFromDisk;
+                                currentVersionResolvedFromFallback = true;
+                            }
+                            else {
+                                throw new Error(`No git tags matching pattern "${releaseTagPattern}" for project "${project.name}" were found. You will need to create an initial matching tag to use as a base for determining the next version. Alternatively, you can use the --first-release option or set "release.version.generatorOptions.fallbackCurrentVersionResolver" to "disk" in order to fallback to the version on disk when no matching git tags are found.`);
+                            }
+                        }
+                        else {
+                            currentVersion = latestMatchingGitTag.extractedVersion;
+                            log(`📄 Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}".`);
+                        }
+                    }
+                    else {
+                        if (currentVersionResolvedFromFallback) {
+                            log(`📄 Using the current version ${currentVersion} already resolved from disk fallback.`);
+                        }
+                        else {
+                            log(
+                            // In this code path we know that latestMatchingGitTag is defined, because we are not relying on the fallbackCurrentVersionResolver, so we can safely use the non-null assertion operator
+                            `📄 Using the current version ${currentVersion} already resolved from git tag "${latestMatchingGitTag.tag}".`);
+                        }
+                    }
+                    break;
+                }
+                default:
+                    throw new Error(`Invalid value for options.currentVersionResolver: ${options.currentVersionResolver}`);
+            }
+            if (options.specifier) {
+                log(`📄 Using the provided version specifier "${options.specifier}".`);
+            }
+            /**
+             * If we are versioning independently then we always need to determine the specifier for each project individually, except
+             * for the case where the user has provided an explicit specifier on the command.
+             *
+             * Otherwise, if versioning the projects together we only need to perform this logic if the specifier is still unset from
+             * previous iterations of the loop.
+             *
+             * NOTE: In the case that we have previously determined via conventional commits that no changes are necessary, the specifier
+             * will be explicitly set to `null`, so that is why we only check for `undefined` explicitly here.
+             */
+            if (specifier === undefined ||
+                (options.releaseGroup.projectsRelationship === 'independent' &&
+                    !options.specifier)) {
+                const specifierSource = options.specifierSource;
+                switch (specifierSource) {
+                    case 'conventional-commits': {
+                        if (options.currentVersionResolver !== 'git-tag') {
+                            throw new Error(`Invalid currentVersionResolver "${options.currentVersionResolver}" provided for release group "${options.releaseGroup.name}". Must be "git-tag" when "specifierSource" is "conventional-commits"`);
+                        }
+                        const affectedProjects = options.releaseGroup.projectsRelationship === 'independent'
+                            ? [projectName]
+                            : projects.map((p) => p.name);
+                        // 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
+                            : options.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.`);
+                        }
+                        specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, options.projectGraph, affectedProjects, options.conventionalCommitsConfig);
+                        if (!specifier) {
+                            log(`🚫 No changes were detected using git history and the conventional commits standard.`);
+                            break;
+                        }
+                        // TODO: reevaluate this 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.
+                        if ((0, semver_2.prerelease)(currentVersion ?? '')) {
+                            specifier = 'prerelease';
+                            log(`📄 Resolved the specifier as "${specifier}" since the current version is a prerelease.`);
+                        }
+                        else {
+                            log(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard.`);
+                        }
+                        break;
+                    }
+                    case 'prompt': {
+                        // Only add the release group name to the log if it is one set by the user, otherwise it is useless noise
+                        const maybeLogReleaseGroup = (log) => {
+                            if (options.releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                                return log;
+                            }
+                            return `${log} within release group "${options.releaseGroup.name}"`;
+                        };
+                        if (options.releaseGroup.projectsRelationship === 'independent') {
+                            specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromPrompt)(`${maybeLogReleaseGroup(`What kind of change is this for project "${projectName}"`)}?`, `${maybeLogReleaseGroup(`What is the exact version for project "${projectName}"`)}?`);
+                        }
+                        else {
+                            specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromPrompt)(`${maybeLogReleaseGroup(`What kind of change is this for the ${projects.length} matched projects(s)`)}?`, `${maybeLogReleaseGroup(`What is the exact version for the ${projects.length} matched project(s)`)}?`);
+                        }
+                        break;
+                    }
+                    default:
+                        throw new Error(`Invalid specifierSource "${specifierSource}" provided. Must be one of "prompt" or "conventional-commits"`);
                 }
-                else {
-                    log(`📄 Using the current version ${currentVersion} already resolved from the registry ${registry}`);
+            }
+            // Resolve any local package dependencies for this project (before applying the new version or updating the versionData)
+            const localPackageDependencies = (0, resolve_local_package_dependencies_1.resolveLocalPackageDependencies)(tree, options.projectGraph, projects, projectNameToPackageRootMap, resolvePackageRoot, 
+            // includeAll when the release group is independent, as we may be filtering to a specific subset of projects, but we still want to update their dependents
+            options.releaseGroup.projectsRelationship === 'independent');
+            const dependentProjects = Object.values(localPackageDependencies)
+                .flat()
+                .filter((localPackageDependency) => {
+                return localPackageDependency.target === project.name;
+            });
+            if (!currentVersion) {
+                throw new Error(`The current version for project "${project.name}" could not be resolved. Please report this on https://github.com/nrwl/nx`);
+            }
+            versionData[projectName] = {
+                currentVersion,
+                dependentProjects,
+                // @ts-ignore: The types will be updated in a future version of Nx
+                newVersion: null, // will stay as null in the final result in the case that no changes are detected
+            };
+            if (!specifier) {
+                log(`🚫 Skipping versioning "${packageJson.name}" as no changes were detected.`);
+                continue;
+            }
+            const newVersion = (0, version_1.deriveNewSemverVersion)(currentVersion, specifier, options.preid);
+            versionData[projectName].newVersion = newVersion;
+            (0, devkit_1.writeJson)(tree, packageJsonPath, {
+                ...packageJson,
+                version: newVersion,
+            });
+            log(`✍️  New version ${newVersion} written to ${packageJsonPath}`);
+            if (dependentProjects.length > 0) {
+                log(`✍️  Applying new version ${newVersion} to ${dependentProjects.length} ${dependentProjects.length > 1
+                    ? 'packages which depend'
+                    : 'package which depends'} on ${project.name}`);
+            }
+            for (const dependentProject of dependentProjects) {
+                const dependentPackageRoot = projectNameToPackageRootMap.get(dependentProject.source);
+                if (!dependentPackageRoot) {
+                    throw new Error(`The dependent project "${dependentProject.source}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
                 }
-                break;
+                (0, devkit_1.updateJson)(tree, (0, node_path_1.join)(dependentPackageRoot, 'package.json'), (json) => {
+                    // Auto (i.e.infer existing) by default
+                    let versionPrefix = options.versionPrefix ?? 'auto';
+                    // For auto, we infer the prefix based on the current version of the dependent
+                    if (versionPrefix === 'auto') {
+                        versionPrefix = ''; // we don't want to end up printing auto
+                        const current = json[dependentProject.dependencyCollection][packageName];
+                        if (current) {
+                            const prefixMatch = current.match(/^[~^]/);
+                            if (prefixMatch) {
+                                versionPrefix = prefixMatch[0];
+                            }
+                            else {
+                                versionPrefix = '';
+                            }
+                        }
+                    }
+                    json[dependentProject.dependencyCollection][packageName] = `${versionPrefix}${newVersion}`;
+                    return json;
+                });
             }
-            case 'disk':
-                currentVersion = currentVersionFromDisk;
-                log(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
-                break;
-            default:
-                throw new Error(`Invalid value for options.currentVersionResolver: ${options.currentVersionResolver}`);
         }
-        // Resolve any local package dependencies for this project (before applying the new version)
-        const localPackageDependencies = (0, resolve_local_package_dependencies_1.resolveLocalPackageDependencies)(tree, options.projectGraph, projects, projectNameToPackageRootMap);
-        const newVersion = (0, version_1.deriveNewSemverVersion)(currentVersion, options.specifier, options.preid);
-        (0, devkit_1.writeJson)(tree, packageJsonPath, {
-            ...projectPackageJson,
-            version: newVersion,
-        });
-        log(`✍️  New version ${newVersion} written to ${workspaceRelativePackageJsonPath}`);
-        const dependentProjects = Object.values(localPackageDependencies)
-            .filter((localPackageDependencies) => {
-            return localPackageDependencies.some((localPackageDependency) => localPackageDependency.target === project.name);
-        })
-            .flat();
-        if (dependentProjects.length > 0) {
-            log(`✍️  Applying new version ${newVersion} to ${dependentProjects.length} ${dependentProjects.length > 1
-                ? 'packages which depend'
-                : 'package which depends'} on ${project.name}`);
+        /**
+         * 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, devkit_1.formatFiles)(tree);
+        // Return the version data so that it can be leveraged by the overall version command
+        return {
+            data: versionData,
+            callback: async (tree, opts) => {
+                const cwd = tree.root;
+                const updatedFiles = await (0, update_lock_file_1.updateLockFile)(cwd, opts);
+                return updatedFiles;
+            },
+        };
+    }
+    catch (e) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            devkit_1.output.error({
+                title: e.message,
+            });
+            // Dump the full stack trace in verbose mode
+            console.error(e);
         }
-        for (const dependentProject of dependentProjects) {
-            (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(projectNameToPackageRootMap.get(dependentProject.source), 'package.json'), (json) => {
-                json[dependentProject.dependencyCollection][packageName] = newVersion;
-                return json;
+        else {
+            devkit_1.output.error({
+                title: e.message,
             });
         }
+        process.exit(1);
     }
 }
 exports.releaseVersionGenerator = releaseVersionGenerator;
 exports.default = releaseVersionGenerator;
+function createResolvePackageRoot(customPackageRoot) {
+    return (projectNode) => {
+        // Default to the project root if no custom packageRoot
+        if (!customPackageRoot) {
+            return projectNode.data.root;
+        }
+        return (0, utils_1.interpolate)(customPackageRoot, {
+            workspaceRoot: '',
+            projectRoot: projectNode.data.root,
+            projectName: projectNode.name,
+        });
+    };
+}
 const colors = [
     { instance: chalk.green, spinnerColor: 'green' },
     { instance: chalk.greenBright, spinnerColor: 'green' },

package/src/generators/release-version/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxJSReleaseVersionGenerator",
   "cli": "nx",
   "title": "Implementation details of `nx release version`",
@@ -19,7 +19,17 @@
     },
     "specifier": {
       "type": "string",
-      "description": "Exact version or semver keyword to apply to the selected release group. NOTE: This should be set on the release group level, not the project level."
+      "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
+    },
+    "releaseGroup": {
+      "type": "object",
+      "description": "The resolved release group configuration, including name, relevant to all projects in the current execution."
+    },
+    "specifierSource": {
+      "type": "string",
+      "default": "prompt",
+      "description": "Which approach to use to determine the semver specifier used to bump the version of the project.",
+      "enum": ["prompt", "conventional-commits"]
     },
     "preid": {
       "type": "string",
@@ -33,13 +43,25 @@
       "type": "string",
       "default": "disk",
       "description": "Which approach to use to determine the current version of the project.",
-      "enum": ["registry", "disk"]
+      "enum": ["registry", "disk", "git-tag"]
     },
     "currentVersionResolverMetadata": {
       "type": "object",
       "description": "Additional metadata to pass to the current version resolver.",
       "default": {}
+    },
+    "skipLockFileUpdate": {
+      "type": "boolean",
+      "description": "Whether to skip updating the lock file after updating the version."
+    },
+    "installArgs": {
+      "type": "string",
+      "description": "Additional arguments to pass to the package manager when updating the lock file with an install command."
+    },
+    "installIgnoreScripts": {
+      "type": "boolean",
+      "description": "Whether to ignore install lifecycle scripts when updating the lock file with an install command."
     }
   },
-  "required": ["projects", "projectGraph", "specifier"]
+  "required": ["projects", "projectGraph", "releaseGroup"]
 }

package/src/generators/release-version/utils/resolve-local-package-dependencies.d.ts

@@ -1,6 +1,12 @@
 import { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode, Tree } from '@nx/devkit';
 interface LocalPackageDependency extends ProjectGraphDependency {
+    /**
+     * The rawVersionSpec contains the value of the version spec as it was defined in the package.json
+     * of the dependent project. This can be useful in cases where the version spec is a range, path or
+     * workspace reference, and it needs to be be reverted to that original value as part of the release.
+     */
+    rawVersionSpec: string;
     dependencyCollection: 'dependencies' | 'devDependencies' | 'optionalDependencies';
 }
-export declare function resolveLocalPackageDependencies(tree: Tree, projectGraph: ProjectGraph, projects: ProjectGraphProjectNode[], projectNameToPackageRootMap: Map<string, string>): Record<string, LocalPackageDependency[]>;
+export declare function resolveLocalPackageDependencies(tree: Tree, projectGraph: ProjectGraph, filteredProjects: ProjectGraphProjectNode[], projectNameToPackageRootMap: Map<string, string>, resolvePackageRoot: (projectNode: ProjectGraphProjectNode) => string, includeAll?: boolean): Record<string, LocalPackageDependency[]>;
 export {};

package/src/generators/release-version/utils/resolve-local-package-dependencies.js

@@ -5,15 +5,24 @@ const devkit_1 = require("@nx/devkit");
 const semver_1 = require("semver");
 const package_1 = require("./package");
 const resolve_version_spec_1 = require("./resolve-version-spec");
-function resolveLocalPackageDependencies(tree, projectGraph, projects, projectNameToPackageRootMap) {
+function resolveLocalPackageDependencies(tree, projectGraph, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll = false) {
     const localPackageDependencies = {};
     const projectNodeToPackageMap = new Map();
+    const projects = includeAll
+        ? Object.values(projectGraph.nodes)
+        : filteredProjects;
     // Iterate through the projects being released and resolve any relevant package.json data
     for (const projectNode of projects) {
         // Resolve the package.json path for the project, taking into account any custom packageRoot settings
-        const packageRoot = projectNameToPackageRootMap.get(projectNode.name);
-        if (!packageRoot) {
-            continue;
+        let packageRoot = projectNameToPackageRootMap.get(projectNode.name);
+        // packageRoot wasn't added to the map yet, try to resolve it dynamically
+        if (!packageRoot && includeAll) {
+            packageRoot = resolvePackageRoot(projectNode);
+            if (!packageRoot) {
+                continue;
+            }
+            // Append it to the map for later use within the release version generator
+            projectNameToPackageRootMap.set(projectNode.name, packageRoot);
         }
         const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
         if (!tree.exists(packageJsonPath)) {
@@ -55,6 +64,7 @@ function resolveLocalPackageDependencies(tree, projectGraph, projects, projectNa
                     {
                         ...dep,
                         dependencyCollection: sourceNpmDependency.collection,
+                        rawVersionSpec: sourceNpmDependency.spec,
                     },
                 ];
             }

package/src/generators/release-version/utils/resolve-version-spec.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveVersionSpec = void 0;
 const npa = require("npm-package-arg");
+const devkit_1 = require("@nx/devkit");
 function resolveVersionSpec(name, version, spec, location) {
     // yarn classic uses link instead of file, normalize to match what npm expects
     spec = spec.replace(/^link:/, 'file:');
@@ -21,6 +22,8 @@ function resolveVersionSpec(name, version, spec, location) {
         }
     }
     const npaResult = npa.resolve(name, spec, location);
-    return npaResult.fetchSpec;
+    return npaResult.fetchSpec.includes('\\')
+        ? (0, devkit_1.normalizePath)(npaResult.fetchSpec)
+        : npaResult.fetchSpec;
 }
 exports.resolveVersionSpec = resolveVersionSpec;

package/src/generators/release-version/utils/update-lock-file.d.ts

@@ -0,0 +1,5 @@
+export declare function updateLockFile(cwd: string, { dryRun, verbose, generatorOptions, }: {
+    dryRun?: boolean;
+    verbose?: boolean;
+    generatorOptions?: Record<string, unknown>;
+}): Promise<string[]>;