@nx/js 17.0.4 → 17.0.6

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

@@ -3,367 +3,112 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.releaseVersionGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
 const chalk = require("chalk");
-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 child_process_1 = require("child_process");
 const version_1 = require("nx/src/command-line/release/version");
 const utils_1 = require("nx/src/tasks-runner/utils");
 const ora = require("ora");
-const semver_2 = require("semver");
-const npm_config_1 = require("../../utils/npm-config");
+const path_1 = require("path");
 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) {
-    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/, '');
-        }
-        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}.
-
+    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.`);
-            }
-            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;
+        }
+        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);
                             }
-                            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.`);
+                            if (stderr) {
+                                return reject(stderr);
                             }
-                        }
-                    }
-                    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,
+                            return resolve(stdout.trim());
                         });
-                        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"`);
+                    });
+                    spinner.stop();
+                    log(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from 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`);
+                else {
+                    log(`📄 Using the current version ${currentVersion} already resolved from the registry ${registry}`);
                 }
-                (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;
-                });
+                break;
             }
+            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}`);
         }
-        /**
-         * 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);
+        // 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}`);
         }
-        else {
-            devkit_1.output.error({
-                title: e.message,
+        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;
             });
         }
-        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": "https://json-schema.org/schema",
+  "$schema": "http://json-schema.org/schema",
   "$id": "NxJSReleaseVersionGenerator",
   "cli": "nx",
   "title": "Implementation details of `nx release version`",
@@ -19,17 +19,7 @@
     },
     "specifier": {
       "type": "string",
-      "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"]
+      "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."
     },
     "preid": {
       "type": "string",
@@ -43,25 +33,13 @@
       "type": "string",
       "default": "disk",
       "description": "Which approach to use to determine the current version of the project.",
-      "enum": ["registry", "disk", "git-tag"]
+      "enum": ["registry", "disk"]
     },
     "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", "releaseGroup"]
+  "required": ["projects", "projectGraph", "specifier"]
 }

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

@@ -1,12 +1,6 @@
 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, filteredProjects: ProjectGraphProjectNode[], projectNameToPackageRootMap: Map<string, string>, resolvePackageRoot: (projectNode: ProjectGraphProjectNode) => string, includeAll?: boolean): Record<string, LocalPackageDependency[]>;
+export declare function resolveLocalPackageDependencies(tree: Tree, projectGraph: ProjectGraph, projects: ProjectGraphProjectNode[], projectNameToPackageRootMap: Map<string, string>): Record<string, LocalPackageDependency[]>;
 export {};

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

@@ -5,24 +5,15 @@ 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, filteredProjects, projectNameToPackageRootMap, resolvePackageRoot, includeAll = false) {
+function resolveLocalPackageDependencies(tree, projectGraph, projects, projectNameToPackageRootMap) {
     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
-        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 packageRoot = projectNameToPackageRootMap.get(projectNode.name);
+        if (!packageRoot) {
+            continue;
         }
         const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
         if (!tree.exists(packageJsonPath)) {
@@ -64,7 +55,6 @@ function resolveLocalPackageDependencies(tree, projectGraph, filteredProjects, p
                     {
                         ...dep,
                         dependencyCollection: sourceNpmDependency.collection,
-                        rawVersionSpec: sourceNpmDependency.spec,
                     },
                 ];
             }

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

@@ -2,7 +2,6 @@
 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:');
@@ -22,8 +21,6 @@ function resolveVersionSpec(name, version, spec, location) {
         }
     }
     const npaResult = npa.resolve(name, spec, location);
-    return npaResult.fetchSpec.includes('\\')
-        ? (0, devkit_1.normalizePath)(npaResult.fetchSpec)
-        : npaResult.fetchSpec;
+    return npaResult.fetchSpec;
 }
 exports.resolveVersionSpec = resolveVersionSpec;

package/src/generators/setup-build/generator.js

@@ -5,7 +5,6 @@ const devkit_1 = require("@nx/devkit");
 const add_swc_config_1 = require("../../utils/swc/add-swc-config");
 const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
 const versions_1 = require("../../utils/versions");
-const add_build_target_defaults_1 = require("@nx/devkit/src/generators/add-build-target-defaults");
 async function setupBuildGenerator(tree, options) {
     const tasks = [];
     const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
@@ -102,7 +101,6 @@ async function setupBuildGenerator(tree, options) {
             break;
         }
         case 'tsc': {
-            (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/js:tsc');
             const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
             project.targets[buildTarget] = {
                 executor: `@nx/js:tsc`,
@@ -118,7 +116,6 @@ async function setupBuildGenerator(tree, options) {
             break;
         }
         case 'swc': {
-            (0, add_build_target_defaults_1.addBuildTargetDefaults)(tree, '@nx/js:swc');
             const outputPath = (0, devkit_1.joinPathFragments)('dist', project.root);
             project.targets[buildTarget] = {
                 executor: `@nx/js:swc`,

package/src/generators/setup-build/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://json-schema.org/schema",
+  "$schema": "http://json-schema.org/schema",
   "$id": "SetupBuild",
   "title": "Setup Build",
   "description": "Sets up build target for a project.",

package/src/generators/setup-verdaccio/schema.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "https://json-schema.org/schema",
+  "$schema": "http://json-schema.org/schema",
   "$id": "SetupVerdaccio",
   "title": "Setup Verdaccio",
   "description": "Setup Verdaccio local-registry.",