@nx/js 17.2.0-beta.0 → 17.2.0-beta.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "17.2.0-beta.0",
+  "version": "17.2.0-beta.10",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -57,9 +57,9 @@
     "semver": "7.5.3",
     "source-map-support": "0.5.19",
     "tslib": "^2.3.0",
-    "@nx/devkit": "17.2.0-beta.0",
-    "@nx/workspace": "17.2.0-beta.0",
-    "@nrwl/js": "17.2.0-beta.0"
+    "@nx/devkit": "17.2.0-beta.10",
+    "@nx/workspace": "17.2.0-beta.10",
+    "@nrwl/js": "17.2.0-beta.10"
   },
   "peerDependencies": {
     "verdaccio": "^5.0.4"

package/src/executors/release-publish/release-publish.impl.js

@@ -27,24 +27,111 @@ async function runExecutor(options, context) {
         ? `package "${packageName}"`
         : `package "${packageName}" from project "${context.projectName}"`;
     if (projectPackageJson.private === true) {
-        console.warn(`Skipping ${packageTxt}, because it has \`"private": true\` in ${packageJsonPath}`);
+        console.warn(`Skipped ${packageTxt}, because it has \`"private": true\` in ${packageJsonPath}`);
         return {
             success: true,
         };
     }
     const npmPublishCommandSegments = [`npm publish --json`];
+    const npmViewCommandSegments = [
+        `npm view ${packageName} versions dist-tags --json`,
+    ];
     if (options.registry) {
         npmPublishCommandSegments.push(`--registry=${options.registry}`);
+        npmViewCommandSegments.push(`--registry=${options.registry}`);
     }
     if (options.tag) {
         npmPublishCommandSegments.push(`--tag=${options.tag}`);
     }
+    if (options.otp) {
+        npmPublishCommandSegments.push(`--otp=${options.otp}`);
+    }
     if (options.dryRun) {
         npmPublishCommandSegments.push(`--dry-run`);
     }
     // Resolve values using the `npm config` command so that things like environment variables and `publishConfig`s are accounted for
     const registry = options.registry ?? (0, child_process_1.execSync)(`npm config get registry`).toString().trim();
     const tag = options.tag ?? (0, child_process_1.execSync)(`npm config get tag`).toString().trim();
+    /**
+     * In a dry-run scenario, it is most likely that all commands are being run with dry-run, therefore
+     * the most up to date/relevant version might not exist on disk for us to read and make the npm view
+     * request with.
+     *
+     * Therefore, so as to not produce misleading output in dry around dist-tags being altered, we do not
+     * perform the npm view step, and just show npm publish's dry-run output.
+     */
+    if (!options.dryRun) {
+        const currentVersion = projectPackageJson.version;
+        try {
+            const result = (0, child_process_1.execSync)(npmViewCommandSegments.join(' '), {
+                env: processEnv(true),
+                cwd: packageRoot,
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            const resultJson = JSON.parse(result.toString());
+            const distTags = resultJson['dist-tags'] || {};
+            if (distTags[tag] === currentVersion) {
+                console.warn(`Skipped ${packageTxt} because v${currentVersion} already exists in ${registry} with tag "${tag}"`);
+                return {
+                    success: true,
+                };
+            }
+            if (resultJson.versions.includes(currentVersion)) {
+                try {
+                    if (!options.dryRun) {
+                        (0, child_process_1.execSync)(`npm dist-tag add ${packageName}@${currentVersion} ${tag} --registry=${registry}`, {
+                            env: processEnv(true),
+                            cwd: packageRoot,
+                            stdio: 'ignore',
+                        });
+                        console.log(`Added the dist-tag ${tag} to v${currentVersion} for registry ${registry}.\n`);
+                    }
+                    else {
+                        console.log(`Would add the dist-tag ${tag} to v${currentVersion} for registry ${registry}, but ${chalk.keyword('orange')('[dry-run]')} was set.\n`);
+                    }
+                    return {
+                        success: true,
+                    };
+                }
+                catch (err) {
+                    try {
+                        const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+                        console.error('npm dist-tag add error:');
+                        if (stdoutData.error.summary) {
+                            console.error(stdoutData.error.summary);
+                        }
+                        if (stdoutData.error.detail) {
+                            console.error(stdoutData.error.detail);
+                        }
+                        if (context.isVerbose) {
+                            console.error('npm dist-tag add stdout:');
+                            console.error(JSON.stringify(stdoutData, null, 2));
+                        }
+                        return {
+                            success: false,
+                        };
+                    }
+                    catch (err) {
+                        console.error('Something unexpected went wrong when processing the npm dist-tag add output\n', err);
+                        return {
+                            success: false,
+                        };
+                    }
+                }
+            }
+        }
+        catch (err) {
+            const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+            // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
+            if (!(stdoutData.error?.code?.includes('E404') &&
+                stdoutData.error?.summary?.includes('no such package available'))) {
+                console.error(`Something unexpected went wrong when checking for existing dist-tags.\n`, err);
+                return {
+                    success: false,
+                };
+            }
+        }
+    }
     try {
         const output = (0, child_process_1.execSync)(npmPublishCommandSegments.join(' '), {
             maxBuffer: LARGE_BUFFER,
@@ -68,22 +155,7 @@ async function runExecutor(options, context) {
     }
     catch (err) {
         try {
-            const currentVersion = projectPackageJson.version;
             const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
-            if (
-            // handle npm conflict error
-            stdoutData.error?.code === 'EPUBLISHCONFLICT' ||
-                // handle npm conflict error when the package has a scope
-                (stdoutData.error?.code === 'E403' &&
-                    stdoutData.error?.summary?.includes('You cannot publish over the previously published versions')) ||
-                // handle verdaccio conflict error
-                (stdoutData.error?.code === 'E409' &&
-                    stdoutData.error?.summary?.includes('this package is already present'))) {
-                console.warn(`Skipping ${packageTxt}, as v${currentVersion} has already been published to ${registry} with tag "${tag}"`);
-                return {
-                    success: true,
-                };
-            }
             console.error('npm publish error:');
             if (stdoutData.error.summary) {
                 console.error(stdoutData.error.summary);
@@ -100,8 +172,6 @@ async function runExecutor(options, context) {
             };
         }
         catch (err) {
-            // npm v9 onwards seems to guarantee stdout will be well formed JSON when --json is used, so maybe we need to
-            // specify that as minimum supported version? (comes with node 18 and 20 by default)
             console.error('Something unexpected went wrong when processing the npm publish output\n', err);
             return {
                 success: false,

package/src/executors/release-publish/schema.d.ts

@@ -2,5 +2,6 @@ export interface PublishExecutorSchema {
   packageRoot?: string;
   registry?: string;
   tag?: string;
+  otp?: number;
   dryRun?: boolean;
 }

package/src/generators/library/library.js

@@ -162,9 +162,6 @@ function addProject(tree, options) {
 }
 async function addLint(tree, options) {
     const { lintProjectGenerator } = (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
-    const { mapLintPattern } = 
-    // nx-ignore-next-line
-    require('@nx/eslint/src/generators/lint-project/lint-project');
     const projectConfiguration = (0, devkit_1.readProjectConfiguration)(tree, options.name);
     const task = lintProjectGenerator(tree, {
         project: options.name,
@@ -174,9 +171,6 @@ async function addLint(tree, options) {
             (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.lib.json'),
         ],
         unitTestRunner: options.unitTestRunner,
-        eslintFilePatterns: [
-            mapLintPattern(options.projectRoot, options.js ? 'js' : 'ts', options.rootProject),
-        ],
         setParserOptionsProject: options.setParserOptionsProject,
         rootProject: options.rootProject,
     });

package/src/generators/release-version/release-version.d.ts

@@ -1,4 +1,5 @@
 import { Tree } from '@nx/devkit';
+import { VersionData } from 'nx/src/command-line/release/version';
 import { ReleaseVersionGeneratorSchema } from './schema';
-export declare function releaseVersionGenerator(tree: Tree, options: ReleaseVersionGeneratorSchema): Promise<void>;
+export declare function releaseVersionGenerator(tree: Tree, options: ReleaseVersionGeneratorSchema): Promise<VersionData>;
 export default releaseVersionGenerator;

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

@@ -4,6 +4,7 @@ exports.releaseVersionGenerator = void 0;
 const devkit_1 = require("@nx/devkit");
 const chalk = require("chalk");
 const child_process_1 = require("child_process");
+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");
@@ -15,23 +16,28 @@ const semver_2 = require("semver");
 const resolve_local_package_dependencies_1 = require("./utils/resolve-local-package-dependencies");
 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 && !(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.`);
         }
         const projects = options.projects;
+        const createResolvePackageRoot = (customPackageRoot) => (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 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, 
-            // 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,
-                }));
+            projectNameToPackageRootMap.set(project.name, resolvePackageRoot(project));
         }
         let currentVersion;
         // only used for options.currentVersionResolver === 'git-tag', but
@@ -65,8 +71,12 @@ To fix this you will either need to add a package.json file at that location, or
                         (await getNpmRegistry()) ??
                         '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) {
+                    /**
+                     * 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;
@@ -96,13 +106,15 @@ To fix this you will either need to add a package.json file at that location, or
                     log(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
                     break;
                 case 'git-tag': {
-                    if (!currentVersion) {
+                    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,
                         });
                         if (!latestMatchingGitTag) {
-                            throw new Error(`No git tags matching pattern "${releaseTagPattern}" for project "${project.name}" were found.`);
+                            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.`);
                         }
                         currentVersion = latestMatchingGitTag.extractedVersion;
                         log(`📄 Resolved the current version as ${currentVersion} from git tag "${latestMatchingGitTag.tag}".`);
@@ -118,8 +130,19 @@ To fix this you will either need to add a package.json file at that location, or
             if (options.specifier) {
                 log(`📄 Using the provided version specifier "${options.specifier}".`);
             }
-            // if specifier is null, then we determined previously via conventional commits that no changes are necessary
-            if (specifier === undefined) {
+            /**
+             * 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':
@@ -131,6 +154,8 @@ To fix this you will either need to add a package.json file at that location, or
                             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)) {
@@ -141,30 +166,51 @@ To fix this you will either need to add a package.json file at that location, or
                             log(`📄 Resolved the specifier as "${specifier}" using git history and the conventional commits standard.`);
                         }
                         break;
-                    case 'prompt':
-                        specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromPrompt)(`What kind of change is this for the ${projects.length} matched projects(s) within release group "${options.releaseGroup.name}"?`, `What is the exact version for the ${projects.length} matched project(s) within release group "${options.releaseGroup.name}"?`);
+                    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.CATCH_ALL_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"`);
                 }
             }
+            // 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;
+            });
+            versionData[projectName] = {
+                currentVersion,
+                dependentProjects,
+                newVersion: null, // will stay as null in the final result the case that no changes are detected
+            };
             if (!specifier) {
                 log(`🚫 Skipping versioning "${projectPackageJson.name}" as no changes were detected.`);
                 continue;
             }
-            // 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, specifier, options.preid);
+            versionData[projectName].newVersion = newVersion;
             (0, devkit_1.writeJson)(tree, packageJsonPath, {
                 ...projectPackageJson,
                 version: newVersion,
             });
             log(`✍️  New version ${newVersion} written to ${workspaceRelativePackageJsonPath}`);
-            const dependentProjects = Object.values(localPackageDependencies)
-                .flat()
-                .filter((localPackageDependency) => {
-                return localPackageDependency.target === project.name;
-            });
             if (dependentProjects.length > 0) {
                 log(`✍️  Applying new version ${newVersion} to ${dependentProjects.length} ${dependentProjects.length > 1
                     ? 'packages which depend'
@@ -178,6 +224,13 @@ To fix this you will either need to add a package.json file at that location, or
                 });
             }
         }
+        /**
+         * Ensure that formatting is applied so that version bump diffs are as mimimal 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 versionData;
     }
     catch (e) {
         if (process.env.NX_VERBOSE_LOGGING === 'true') {

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

@@ -2,5 +2,5 @@ import { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode, Tree } f
 interface LocalPackageDependency extends ProjectGraphDependency {
     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)) {

package/src/utils/find-npm-dependencies.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findNpmDependencies = void 0;
 const path_1 = require("path");
 const configuration_1 = require("nx/src/config/configuration");
-const task_hasher_1 = require("nx/src/hasher/task-hasher");
 const devkit_1 = require("@nx/devkit");
 const fileutils_1 = require("nx/src/utils/fileutils");
 const project_graph_1 = require("nx/src/config/project-graph");
 const ts_config_1 = require("./typescript/ts-config");
+const task_hasher_1 = require("nx/src/hasher/task-hasher");
 /**
  * Finds all npm dependencies and their expected versions for a given project.
  */