@nx/js 19.1.0-canary.20240523-261b0ff → 19.1.0

package/package.json

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

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

@@ -16,6 +16,7 @@ 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");
+const sort_projects_topologically_1 = require("./utils/sort-projects-topologically");
 async function releaseVersionGenerator(tree, options) {
     try {
         const versionData = {};
@@ -39,7 +40,15 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
             // always use disk as a fallback for the first release
             options.fallbackCurrentVersionResolver = 'disk';
         }
-        const projects = options.projects;
+        // Set default for updateDependents
+        const updateDependents = options.updateDependents ?? 'never';
+        const updateDependentsBump = 'patch';
+        // Sort the projects topologically if update dependents is enabled
+        // TODO: maybe move this sorting to the command level?
+        const projects = updateDependents === 'never'
+            ? options.projects
+            : (0, sort_projects_topologically_1.sortProjectsTopologically)(options.projectGraph, options.projects);
+        const projectToDependencyBumps = new Map();
         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();
@@ -143,6 +152,9 @@ To fix this you will either need to add a package.json file at that location, or
                 }
                 case 'disk':
                     currentVersion = currentVersionFromDisk;
+                    if (!currentVersion) {
+                        throw new Error(`Unable to determine the current version for project "${project.name}" from ${packageJsonPath}`);
+                    }
                     log(`📄 Resolved the current version as ${currentVersion} from ${packageJsonPath}`);
                     break;
                 case 'git-tag': {
@@ -221,10 +233,16 @@ To fix this you will either need to add a package.json file at that location, or
                         }
                         specifier = await (0, resolve_semver_specifier_1.resolveSemverSpecifierFromConventionalCommits)(previousVersionRef, options.projectGraph, affectedProjects, options.conventionalCommitsConfig);
                         if (!specifier) {
+                            if (projectToDependencyBumps.has(projectName)) {
+                                // No applicable changes to the project directly by the user, but one or more dependencies have been bumped and updateDependents is enabled
+                                specifier = updateDependentsBump;
+                                log(`📄 Resolved the specifier as "${specifier}" because "release.version.generatorOptions.updateDependents" is enabled`);
+                                break;
+                            }
                             log(`🚫 No changes were detected using git history and the conventional commits standard.`);
                             break;
                         }
-                        // TODO: reevaluate this logic/workflow for independent projects
+                        // TODO: reevaluate this prerelease logic/workflow for independent projects
                         //
                         // Always assume that if the current version is a prerelease, then the next version should be a prerelease.
                         // Users must manually graduate from a prerelease to a release by providing an explicit specifier.
@@ -261,19 +279,70 @@ To fix this you will either need to add a package.json file at that location, or
             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)
+            const allDependentProjects = Object.values(localPackageDependencies)
                 .flat()
                 .filter((localPackageDependency) => {
                 return localPackageDependency.target === project.name;
             });
+            const includeTransitiveDependents = updateDependents === 'auto';
+            const transitiveLocalPackageDependents = [];
+            if (includeTransitiveDependents) {
+                for (const directDependent of allDependentProjects) {
+                    // Look through localPackageDependencies to find any which have a target on the current dependent
+                    for (const localPackageDependency of Object.values(localPackageDependencies).flat()) {
+                        if (localPackageDependency.target === directDependent.source) {
+                            transitiveLocalPackageDependents.push(localPackageDependency);
+                        }
+                    }
+                }
+            }
+            const dependentProjectsInCurrentBatch = [];
+            const dependentProjectsOutsideCurrentBatch = [];
+            // Track circular dependencies using value of project1:project2
+            const circularDependencies = new Set();
+            for (const dependentProject of allDependentProjects) {
+                // Track circular dependencies (add both directions for easy look up)
+                if (dependentProject.target === projectName) {
+                    circularDependencies.add(`${dependentProject.source}:${dependentProject.target}`);
+                    circularDependencies.add(`${dependentProject.target}:${dependentProject.source}`);
+                }
+                const isInCurrentBatch = options.projects.some((project) => project.name === dependentProject.source);
+                if (!isInCurrentBatch) {
+                    dependentProjectsOutsideCurrentBatch.push(dependentProject);
+                }
+                else {
+                    dependentProjectsInCurrentBatch.push(dependentProject);
+                }
+            }
+            // If not always updating dependents (when they don't already appear in the batch itself), print a warning to the user about what is being skipped and how to change it
+            if (updateDependents === 'never') {
+                if (dependentProjectsOutsideCurrentBatch.length > 0) {
+                    let logMsg = `⚠️  Warning, the following packages depend on "${project.name}"`;
+                    if (options.releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
+                        logMsg += ` but have been filtered out via --projects, and therefore will not be updated:`;
+                    }
+                    else {
+                        logMsg += ` but are either not part of the current release group "${options.releaseGroup.name}", or have been filtered out via --projects, and therefore will not be updated:`;
+                    }
+                    const indent = Array.from(new Array(projectName.length + 4))
+                        .map(() => ' ')
+                        .join('');
+                    logMsg += `\n${dependentProjectsOutsideCurrentBatch
+                        .map((dependentProject) => `${indent}- ${dependentProject.source}`)
+                        .join('\n')}`;
+                    logMsg += `\n${indent}=> You can adjust this behavior by setting \`version.generatorOptions.updateDependents\` to "auto"`;
+                    log(logMsg);
+                }
+            }
             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
+                dependentProjects: updateDependents === 'auto'
+                    ? allDependentProjects
+                    : dependentProjectsInCurrentBatch,
             };
             if (!specifier) {
                 log(`🚫 Skipping versioning "${packageJson.name}" as no changes were detected.`);
@@ -286,25 +355,30 @@ To fix this you will either need to add a package.json file at that location, or
                 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`);
+            if (allDependentProjects.length > 0) {
+                const totalProjectsToUpdate = updateDependents === 'auto'
+                    ? allDependentProjects.length +
+                        transitiveLocalPackageDependents.length -
+                        // There are two entries per circular dep
+                        circularDependencies.size / 2
+                    : dependentProjectsInCurrentBatch.length;
+                if (totalProjectsToUpdate > 0) {
+                    log(`✍️  Applying new version ${newVersion} to ${totalProjectsToUpdate} ${totalProjectsToUpdate > 1
+                        ? 'packages which depend'
+                        : 'package which depends'} on ${project.name}`);
                 }
-                (0, devkit_1.updateJson)(tree, (0, node_path_1.join)(dependentPackageRoot, 'package.json'), (json) => {
+            }
+            const updateDependentProjectAndAddToVersionData = ({ dependentProject, dependencyPackageName, newDependencyVersion, forceVersionBump, }) => {
+                const updatedFilePath = (0, devkit_1.joinPathFragments)(projectNameToPackageRootMap.get(dependentProject.source), 'package.json');
+                (0, devkit_1.updateJson)(tree, updatedFilePath, (json) => {
                     // Auto (i.e.infer existing) by default
                     let versionPrefix = options.versionPrefix ?? 'auto';
+                    const currentDependencyVersion = json[dependentProject.dependencyCollection][dependencyPackageName];
                     // 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 (currentDependencyVersion) {
+                            const prefixMatch = currentDependencyVersion.match(/^[~^]/);
                             if (prefixMatch) {
                                 versionPrefix = prefixMatch[0];
                             }
@@ -313,9 +387,76 @@ To fix this you will either need to add a package.json file at that location, or
                             }
                         }
                     }
-                    json[dependentProject.dependencyCollection][packageName] = `${versionPrefix}${newVersion}`;
+                    // Apply the new version of the dependency to the dependent
+                    const newDepVersion = `${versionPrefix}${newDependencyVersion}`;
+                    json[dependentProject.dependencyCollection][dependencyPackageName] =
+                        newDepVersion;
+                    // Bump the dependent's version if applicable and record it in the version data
+                    if (forceVersionBump) {
+                        const currentPackageVersion = json.version;
+                        const newPackageVersion = (0, version_1.deriveNewSemverVersion)(currentPackageVersion, forceVersionBump, options.preid);
+                        json.version = newPackageVersion;
+                        // Look up any dependent projects from the transitiveLocalPackageDependents list
+                        const transitiveDependentProjects = transitiveLocalPackageDependents.filter((localPackageDependency) => localPackageDependency.target === dependentProject.source);
+                        versionData[dependentProject.source] = {
+                            currentVersion: currentPackageVersion,
+                            newVersion: newPackageVersion,
+                            dependentProjects: transitiveDependentProjects,
+                        };
+                    }
                     return json;
                 });
+            };
+            for (const dependentProject of dependentProjectsInCurrentBatch) {
+                if (projectToDependencyBumps.has(dependentProject.source)) {
+                    const dependencyBumps = projectToDependencyBumps.get(dependentProject.source);
+                    dependencyBumps.add(projectName);
+                }
+                else {
+                    projectToDependencyBumps.set(dependentProject.source, new Set([projectName]));
+                }
+                updateDependentProjectAndAddToVersionData({
+                    dependentProject,
+                    dependencyPackageName: packageName,
+                    newDependencyVersion: newVersion,
+                    // We don't force bump because we know they will come later in the topologically sorted projects loop and may have their own version update logic to take into account
+                    forceVersionBump: false,
+                });
+            }
+            if (updateDependents === 'auto') {
+                for (const dependentProject of dependentProjectsOutsideCurrentBatch) {
+                    updateDependentProjectAndAddToVersionData({
+                        dependentProject,
+                        dependencyPackageName: packageName,
+                        newDependencyVersion: newVersion,
+                        // For these additional dependents, we need to update their package.json version as well because we know they will not come later in the topologically sorted projects loop
+                        forceVersionBump: updateDependentsBump,
+                    });
+                }
+            }
+            for (const transitiveDependentProject of transitiveLocalPackageDependents) {
+                // Check if the transitive dependent originates from a circular dependency
+                const isFromCircularDependency = circularDependencies.has(`${transitiveDependentProject.source}:${transitiveDependentProject.target}`);
+                const dependencyProjectName = transitiveDependentProject.target;
+                const dependencyPackageRoot = projectNameToPackageRootMap.get(dependencyProjectName);
+                if (!dependencyPackageRoot) {
+                    throw new Error(`The project "${dependencyProjectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
+                }
+                const dependencyPackageJsonPath = (0, node_path_1.join)(dependencyPackageRoot, 'package.json');
+                const dependencyPackageJson = (0, devkit_1.readJson)(tree, dependencyPackageJsonPath);
+                updateDependentProjectAndAddToVersionData({
+                    dependentProject: transitiveDependentProject,
+                    dependencyPackageName: dependencyPackageJson.name,
+                    newDependencyVersion: dependencyPackageJson.version,
+                    /**
+                     * For these additional dependents, we need to update their package.json version as well because we know they will not come later in the topologically sorted projects loop.
+                     * The one exception being if the dependent is part of a circular dependency, in which case we don't want to force a version bump as this would come in addition to the one
+                     * already applied.
+                     */
+                    forceVersionBump: isFromCircularDependency
+                        ? false
+                        : updateDependentsBump,
+                });
             }
         }
         /**

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

@@ -1,5 +1,5 @@
 import { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode, Tree } from '@nx/devkit';
-interface LocalPackageDependency extends ProjectGraphDependency {
+export 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
@@ -9,4 +9,3 @@ interface LocalPackageDependency extends ProjectGraphDependency {
     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 {};

package/src/generators/release-version/utils/sort-projects-topologically.d.ts

@@ -0,0 +1,2 @@
+import { ProjectGraph, ProjectGraphProjectNode } from '@nx/devkit';
+export declare function sortProjectsTopologically(projectGraph: ProjectGraph, projectNodes: ProjectGraphProjectNode[]): ProjectGraphProjectNode[];

package/src/generators/release-version/utils/sort-projects-topologically.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortProjectsTopologically = void 0;
+function sortProjectsTopologically(projectGraph, projectNodes) {
+    const edges = new Map(projectNodes.map((node) => [node, 0]));
+    const filteredDependencies = [];
+    for (const node of projectNodes) {
+        const deps = projectGraph.dependencies[node.name];
+        if (deps) {
+            filteredDependencies.push(...deps.filter((dep) => projectNodes.find((n) => n.name === dep.target)));
+        }
+    }
+    filteredDependencies.forEach((dep) => {
+        const sourceNode = projectGraph.nodes[dep.source];
+        // dep.source depends on dep.target
+        edges.set(sourceNode, (edges.get(sourceNode) || 0) + 1);
+    });
+    // Initialize queue with projects that have no dependencies
+    const processQueue = [...edges]
+        .filter(([_, count]) => count === 0)
+        .map(([node]) => node);
+    const sortedProjects = [];
+    while (processQueue.length > 0) {
+        const node = processQueue.shift();
+        sortedProjects.push(node);
+        // Process each project that depends on the current node
+        filteredDependencies.forEach((dep) => {
+            const dependentNode = projectGraph.nodes[dep.source];
+            const count = edges.get(dependentNode) - 1;
+            edges.set(dependentNode, count);
+            if (count === 0) {
+                processQueue.push(dependentNode);
+            }
+        });
+    }
+    /**
+     * We cannot reliably sort the nodes, e.g. when a circular dependency is present.
+     * For releases, we allow the user to work with a graph that contains cycles, so
+     * we should not throw an error here and simply return the original list of projects.
+     */
+    if (sortedProjects.length !== projectNodes.length) {
+        return projectNodes;
+    }
+    return sortedProjects;
+}
+exports.sortProjectsTopologically = sortProjectsTopologically;

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

@@ -82,8 +82,10 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
 exports.updateLockFile = updateLockFile;
 function execLockFileUpdate(command, cwd, env = {}) {
     try {
+        const LARGE_BUFFER = 1024 * 1000000;
         (0, child_process_1.execSync)(command, {
             cwd,
+            maxBuffer: LARGE_BUFFER,
             env: {
                 ...process.env,
                 ...env,

package/src/plugins/typescript/plugin.js

@@ -12,16 +12,19 @@ const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const cache_directory_1 = require("nx/src/utils/cache-directory");
 const ts_config_1 = require("../../utils/typescript/ts-config");
 const cachePath = (0, node_path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'tsc.hash');
-const targetsCache = (0, node_fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
-const calculatedTargets = {};
+const targetsCache = readTargetsCache();
 function readTargetsCache() {
-    return (0, devkit_1.readJsonFile)(cachePath);
+    return (0, node_fs_1.existsSync)(cachePath) ? (0, devkit_1.readJsonFile)(cachePath) : {};
 }
-function writeTargetsToCache(targets) {
-    (0, devkit_1.writeJsonFile)(cachePath, targets);
+function writeTargetsToCache() {
+    const oldCache = readTargetsCache();
+    (0, devkit_1.writeJsonFile)(cachePath, {
+        ...oldCache,
+        ...targetsCache,
+    });
 }
 const createDependencies = () => {
-    writeTargetsToCache(calculatedTargets);
+    writeTargetsToCache();
     return [];
 };
 exports.createDependencies = createDependencies;
@@ -46,15 +49,12 @@ exports.createNodes = [
         const nodeHash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, pluginOptions, context, [(0, lock_file_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot))]);
         // The hash is calculated at the node/project level, so we add the config file path to avoid conflicts when caching
         const cacheKey = `${nodeHash}_${configFilePath}`;
-        const targets = targetsCache[cacheKey]
-            ? targetsCache[cacheKey]
-            : buildTscTargets(fullConfigPath, projectRoot, pluginOptions, context);
-        calculatedTargets[cacheKey] = targets;
+        targetsCache[cacheKey] ??= buildTscTargets(fullConfigPath, projectRoot, pluginOptions, context);
         return {
             projects: {
                 [projectRoot]: {
                     projectType: 'library',
-                    targets,
+                    targets: targetsCache[cacheKey],
                 },
             },
         };

package/src/utils/typescript/create-ts-config.js

@@ -23,10 +23,12 @@ function extractTsConfigBase(host) {
         return;
     const tsconfig = (0, json_1.readJson)(host, 'tsconfig.json');
     const baseCompilerOptions = {};
-    for (let compilerOption of Object.keys(exports.tsConfigBaseOptions)) {
-        baseCompilerOptions[compilerOption] =
-            tsconfig.compilerOptions[compilerOption];
-        delete tsconfig.compilerOptions[compilerOption];
+    if (tsconfig.compilerOptions) {
+        for (let compilerOption of Object.keys(exports.tsConfigBaseOptions)) {
+            baseCompilerOptions[compilerOption] =
+                tsconfig.compilerOptions[compilerOption];
+            delete tsconfig.compilerOptions[compilerOption];
+        }
     }
     (0, json_1.writeJson)(host, 'tsconfig.base.json', {
         compileOnSave: false,