@nx/js 16.9.0-beta.1 → 16.9.0-beta.3

package/executors.json

@@ -17,6 +17,12 @@
       "schema": "./src/executors/node/schema.json",
       "description": "Execute a Node application."
     },
+    "release-publish": {
+      "implementation": "./src/executors/release-publish/release-publish.impl",
+      "schema": "./src/executors/release-publish/schema.json",
+      "description": "DO NOT INVOKE DIRECTLY WITH `nx run`. Use `nx release publish` instead.",
+      "hidden": true
+    },
     "verdaccio": {
       "implementation": "./src/executors/verdaccio/verdaccio.impl",
       "schema": "./src/executors/verdaccio/schema.json",

package/generators.json

@@ -59,6 +59,12 @@
       "x-type": "library",
       "description": "Convert a TypeScript library to compile with SWC."
     },
+    "release-version": {
+      "factory": "./src/generators/release-version/release-version#releaseVersionGenerator",
+      "schema": "./src/generators/release-version/schema.json",
+      "description": "DO NOT INVOKE DIRECTLY WITH `nx generate`. Use `nx release version` instead.",
+      "hidden": true
+    },
     "setup-verdaccio": {
       "factory": "./src/generators/setup-verdaccio/generator#setupVerdaccio",
       "schema": "./src/generators/setup-verdaccio/schema.json",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "16.9.0-beta.1",
+  "version": "16.9.0-beta.3",
   "private": false,
   "description": "The JS plugin for Nx contains executors and generators that provide the best experience for developing JavaScript and TypeScript projects. ",
   "repository": {
@@ -39,20 +39,24 @@
     "@babel/preset-env": "^7.22.9",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nrwl/js": "16.9.0-beta.1",
-    "@nx/devkit": "16.9.0-beta.1",
-    "@nx/workspace": "16.9.0-beta.1",
+    "@nrwl/js": "16.9.0-beta.3",
+    "@nx/devkit": "16.9.0-beta.3",
+    "@nx/workspace": "16.9.0-beta.3",
     "@phenomnomnominal/tsquery": "~5.0.1",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^2.8.0",
     "babel-plugin-transform-typescript-metadata": "^0.3.1",
     "chalk": "^4.1.0",
+    "columnify": "^1.6.0",
     "detect-port": "^1.5.1",
     "fast-glob": "3.2.7",
     "fs-extra": "^11.1.0",
     "ignore": "^5.0.4",
     "js-tokens": "^4.0.0",
     "minimatch": "3.0.5",
+    "npm-package-arg": "11.0.1",
+    "npm-run-path": "^4.0.1",
+    "ora": "5.3.0",
     "semver": "7.5.3",
     "source-map-support": "0.5.19",
     "ts-node": "10.9.1",
@@ -71,5 +75,5 @@
     "access": "public"
   },
   "type": "commonjs",
-  "gitHead": "5056d6cefb2949ba865019e8b71e633fba28c091"
+  "gitHead": "d5692528c089a75c76b21d2d1235d8cc5dbb1d26"
 }

package/src/executors/node/node.impl.js

@@ -23,7 +23,7 @@ function debounce(fn, wait) {
 async function* nodeExecutor(options, context) {
     process.env.NODE_ENV ??= context?.configurationName ?? 'development';
     const project = context.projectGraph.nodes[context.projectName];
-    const buildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph);
+    const buildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context);
     if (!project.data.targets[buildTarget.target]) {
         throw new Error(`Cannot find build target ${chalk.bold(options.buildTarget)} for project ${chalk.bold(context.projectName)}`);
     }
@@ -229,7 +229,7 @@ function getExecArgv(options) {
     return args;
 }
 function calculateResolveMappings(context, options) {
-    const parsed = (0, devkit_1.parseTargetString)(options.buildTarget, context.projectGraph);
+    const parsed = (0, devkit_1.parseTargetString)(options.buildTarget, context);
     const { dependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, parsed.project, parsed.target, parsed.configuration);
     return dependencies.reduce((m, c) => {
         if (c.node.type !== 'npm' && c.outputs[0] != null) {
@@ -240,7 +240,7 @@ function calculateResolveMappings(context, options) {
 }
 function runWaitUntilTargets(options, context) {
     return Promise.all(options.waitUntilTargets.map(async (waitUntilTarget) => {
-        const target = (0, devkit_1.parseTargetString)(waitUntilTarget, context.projectGraph);
+        const target = (0, devkit_1.parseTargetString)(waitUntilTarget, context);
         const output = await (0, devkit_1.runExecutor)(target, {}, context);
         return new Promise(async (resolve) => {
             let event = await output.next();

package/src/executors/release-publish/format-bytes.d.ts

@@ -0,0 +1 @@
+export declare const formatBytes: (bytes: any, space?: boolean) => string;

package/src/executors/release-publish/format-bytes.js

@@ -0,0 +1,28 @@
+"use strict";
+// Taken from https://github.com/npm/cli/blob/c736b622b8504b07f5a19f631ade42dd40063269/lib/utils/format-bytes.js
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatBytes = void 0;
+// Convert bytes to printable output, for file reporting in tarballs
+// Only supports up to GB because that's way larger than anything the registry
+// supports anyways.
+const formatBytes = (bytes, space = true) => {
+    let spacer = '';
+    if (space) {
+        spacer = ' ';
+    }
+    if (bytes < 1000) {
+        // B
+        return `${bytes}${spacer}B`;
+    }
+    if (bytes < 1000000) {
+        // kB
+        return `${(bytes / 1000).toFixed(1)}${spacer}kB`;
+    }
+    if (bytes < 1000000000) {
+        // MB
+        return `${(bytes / 1000000).toFixed(1)}${spacer}MB`;
+    }
+    // GB
+    return `${(bytes / 1000000000).toFixed(1)}${spacer}GB`;
+};
+exports.formatBytes = formatBytes;

package/src/executors/release-publish/log-tar.d.ts

@@ -0,0 +1 @@
+export declare const logTar: (tarball: any, opts?: {}) => void;

package/src/executors/release-publish/log-tar.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logTar = void 0;
+// Adapted from https://github.com/npm/cli/blob/c736b622b8504b07f5a19f631ade42dd40063269/lib/utils/tar.js
+const chalk = require("chalk");
+const columnify = require("columnify");
+const format_bytes_1 = require("./format-bytes");
+const logTar = (tarball, opts = {}) => {
+    // @ts-ignore
+    const { unicode = true } = opts;
+    console.log('');
+    console.log(`${unicode ? '📦 ' : 'package:'} ${tarball.name}@${tarball.version}`);
+    console.log(chalk.magenta('=== Tarball Contents ==='));
+    if (tarball.files.length) {
+        console.log('');
+        const columnData = columnify(tarball.files
+            .map((f) => {
+            const bytes = (0, format_bytes_1.formatBytes)(f.size, false);
+            return /^node_modules\//.test(f.path)
+                ? null
+                : { path: f.path, size: `${bytes}` };
+        })
+            .filter((f) => f), {
+            include: ['size', 'path'],
+            showHeaders: false,
+        });
+        columnData.split('\n').forEach((line) => {
+            console.log(line);
+        });
+    }
+    if (tarball.bundled.length) {
+        console.log(chalk.magenta('=== Bundled Dependencies ==='));
+        tarball.bundled.forEach((name) => console.log('', name));
+    }
+    console.log(chalk.magenta('=== Tarball Details ==='));
+    console.log(columnify([
+        { name: 'name:', value: tarball.name },
+        { name: 'version:', value: tarball.version },
+        tarball.filename && { name: 'filename:', value: tarball.filename },
+        { name: 'package size:', value: (0, format_bytes_1.formatBytes)(tarball.size) },
+        { name: 'unpacked size:', value: (0, format_bytes_1.formatBytes)(tarball.unpackedSize) },
+        { name: 'shasum:', value: tarball.shasum },
+        {
+            name: 'integrity:',
+            value: tarball.integrity.toString().slice(0, 20) +
+                '[...]' +
+                tarball.integrity.toString().slice(80),
+        },
+        tarball.bundled.length && {
+            name: 'bundled deps:',
+            value: tarball.bundled.length,
+        },
+        tarball.bundled.length && {
+            name: 'bundled files:',
+            value: tarball.entryCount - tarball.files.length,
+        },
+        tarball.bundled.length && {
+            name: 'own files:',
+            value: tarball.files.length,
+        },
+        { name: 'total files:', value: tarball.entryCount },
+    ].filter((x) => x), {
+        include: ['name', 'value'],
+        showHeaders: false,
+    }));
+    console.log('', '');
+};
+exports.logTar = logTar;

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

@@ -0,0 +1,5 @@
+import { ExecutorContext } from '@nx/devkit';
+import { PublishExecutorSchema } from './schema';
+export default function runExecutor(options: PublishExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const npm_run_path_1 = require("npm-run-path");
+const log_tar_1 = require("./log-tar");
+const chalk = require("chalk");
+const LARGE_BUFFER = 1024 * 1000000;
+function processEnv(color) {
+    const env = {
+        ...process.env,
+        ...(0, npm_run_path_1.env)(),
+    };
+    if (color) {
+        env.FORCE_COLOR = `${color}`;
+    }
+    return env;
+}
+async function runExecutor(options, context) {
+    const projectConfig = context.projectsConfigurations.projects[context.projectName];
+    const packageRoot = (0, devkit_1.joinPathFragments)(context.root, options.packageRoot ?? projectConfig.root);
+    const npmPublishCommandSegments = [`npm publish --json`];
+    if (options.registry) {
+        npmPublishCommandSegments.push(`--registry=${options.registry}`);
+    }
+    if (options.tag) {
+        npmPublishCommandSegments.push(`--tag=${options.tag}`);
+    }
+    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();
+    try {
+        const output = (0, child_process_1.execSync)(npmPublishCommandSegments.join(' '), {
+            maxBuffer: LARGE_BUFFER,
+            env: processEnv(true),
+            cwd: packageRoot,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutData = JSON.parse(output.toString());
+        // If npm workspaces are in use, the publish output will nest the data under the package name, so we normalize it first
+        const normalizedStdoutData = stdoutData[context.projectName] ?? stdoutData;
+        (0, log_tar_1.logTar)(normalizedStdoutData);
+        if (options.dryRun) {
+            console.log(`Would publish to ${registry} with tag "${tag}", but ${chalk.keyword('orange')('[dry-run]')} was set`);
+        }
+        else {
+            console.log(`Published to ${registry} with tag "${tag}"`);
+        }
+        return {
+            success: true,
+        };
+    }
+    catch (err) {
+        try {
+            const projectPackageJson = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(packageRoot, 'package.json'));
+            const name = projectPackageJson.name;
+            const currentVersion = projectPackageJson.version;
+            const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+            if (stdoutData.error?.code === 'EPUBLISHCONFLICT' ||
+                (stdoutData.error?.code === 'E403' &&
+                    stdoutData.error?.body?.error?.includes('You cannot publish over the previously published versions'))) {
+                // If package and project name match, make it terser
+                let packageTxt = name === context.projectName
+                    ? `package "${name}"`
+                    : `package "${name}" from project "${context.projectName}"`;
+                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);
+            }
+            if (stdoutData.error.detail) {
+                console.error(stdoutData.error.detail);
+            }
+            return {
+                success: false,
+            };
+        }
+        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,
+            };
+        }
+    }
+}
+exports.default = runExecutor;

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

@@ -0,0 +1,6 @@
+export interface PublishExecutorSchema {
+  packageRoot?: string;
+  registry?: string;
+  tag?: string;
+  dryRun?: boolean;
+}

package/src/executors/release-publish/schema.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "title": "Implementation details of `nx release publish`",
+  "description": "DO NOT INVOKE DIRECTLY WITH `nx run`. Use `nx release publish` instead.",
+  "type": "object",
+  "properties": {
+    "packageRoot": {
+      "type": "string",
+      "description": "The root directory of the directory (containing a manifest file at its root) to publish. Defaults to the project root."
+    },
+    "registry": {
+      "type": "string",
+      "description": "The registry to publish the package to."
+    },
+    "tag": {
+      "type": "string",
+      "description": "The distribution tag to apply to the published package."
+    },
+    "dryRun": {
+      "type": "boolean",
+      "description": "Whether to run the command without actually publishing the package to the registry."
+    }
+  },
+  "required": []
+}

package/src/executors/tsc/lib/batch/build-task-info-per-tsconfig-map.js

@@ -33,7 +33,7 @@ function processTasksAndPopulateTsConfigTaskInfoMap(tsConfigTaskInfoMap, tasksOp
     }
 }
 function createTaskInfo(taskName, taskOptions, context, tsConfig) {
-    const target = (0, devkit_1.parseTargetString)(taskName, context.projectGraph);
+    const target = (0, devkit_1.parseTargetString)(taskName, context);
     const taskContext = {
         ...context,
         // batch executors don't get these in the context, we provide them

package/src/executors/tsc/lib/batch/normalize-tasks-options.js

@@ -5,7 +5,7 @@ const devkit_1 = require("@nx/devkit");
 const normalize_options_1 = require("../normalize-options");
 function normalizeTasksOptions(inputs, context) {
     return Object.entries(inputs).reduce((tasksOptions, [taskName, options]) => {
-        const { project } = (0, devkit_1.parseTargetString)(taskName, context.projectGraph);
+        const { project } = (0, devkit_1.parseTargetString)(taskName, context);
         const { sourceRoot, root } = context.projectsConfigurations.projects[project];
         tasksOptions[taskName] = (0, normalize_options_1.normalizeOptions)(options, context.root, sourceRoot, root);
         return tasksOptions;

package/src/executors/tsc/lib/get-tsconfig.js

@@ -14,7 +14,7 @@ function getProcessedTaskTsConfigs(tasks, tasksOptions, context) {
 exports.getProcessedTaskTsConfigs = getProcessedTaskTsConfigs;
 const projectTsConfigCache = new Map();
 function generateTaskProjectTsConfig(task, tasksOptions, context, taskInMemoryTsConfigMap) {
-    const { project } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    const { project } = (0, devkit_1.parseTargetString)(task, context);
     if (projectTsConfigCache.has(project)) {
         const { tsConfig, tsConfigPath } = projectTsConfigCache.get(project);
         taskInMemoryTsConfigMap[task] = tsConfig;
@@ -48,13 +48,11 @@ function generateTaskProjectTsConfig(task, tasksOptions, context, taskInMemoryTs
     return tsConfigPath;
 }
 function getDependencyTasksInOtherProjects(task, project, context) {
-    return context.taskGraph.dependencies[task].filter((t) => t !== task &&
-        (0, devkit_1.parseTargetString)(t, context.projectGraph).project !== project);
+    return context.taskGraph.dependencies[task].filter((t) => t !== task && (0, devkit_1.parseTargetString)(t, context).project !== project);
 }
 function getDependencyTasksInSameProject(task, context) {
-    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
-    return Object.keys(context.taskGraph.tasks).filter((t) => t !== task &&
-        (0, devkit_1.parseTargetString)(t, context.projectGraph).project === taskProject);
+    const { project: taskProject } = (0, devkit_1.parseTargetString)(task, context);
+    return Object.keys(context.taskGraph.tasks).filter((t) => t !== task && (0, devkit_1.parseTargetString)(t, context).project === taskProject);
 }
 function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences) {
     const originalTsConfig = (0, devkit_1.readJsonFile)(tsConfig, {
@@ -82,7 +80,7 @@ function getInMemoryTsConfig(tsConfig, taskOptions, projectReferences) {
     };
 }
 function hasTscExecutor(task, context) {
-    const { project, target } = (0, devkit_1.parseTargetString)(task, context.projectGraph);
+    const { project, target } = (0, devkit_1.parseTargetString)(task, context);
     return (context.projectGraph.nodes[project].data.targets[target].executor ===
         '@nx/js:tsc');
 }

package/src/executors/tsc/tsc.batch-impl.js

@@ -170,7 +170,7 @@ function createTypescriptCompilationContext(tsConfigTaskInfoMap, taskInMemoryTsC
     Object.entries(taskInMemoryTsConfigMap).forEach(([task, tsConfig]) => {
         if (!tsCompilationContext[tsConfig.path]) {
             tsCompilationContext[tsConfig.path] = {
-                project: (0, devkit_1.parseTargetString)(task, context.projectGraph).project,
+                project: (0, devkit_1.parseTargetString)(task, context).project,
                 transformers: [],
                 tsConfig: tsConfig,
             };

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

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

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

@@ -0,0 +1,131 @@
+"use strict";
+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 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 resolve_local_package_dependencies_1 = require("./utils/resolve-local-package-dependencies");
+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.`);
+        }
+        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 (stderr) {
+                                return reject(stderr);
+                            }
+                            return resolve(stdout.trim());
+                        });
+                    });
+                    spinner.stop();
+                    log(`📄 Resolved the current version as ${currentVersion} for tag "${tag}" from registry ${registry}`);
+                }
+                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;
+            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}`);
+        }
+        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;
+            });
+        }
+    }
+}
+exports.releaseVersionGenerator = releaseVersionGenerator;
+exports.default = releaseVersionGenerator;
+const colors = [
+    { instance: chalk.green, spinnerColor: 'green' },
+    { instance: chalk.greenBright, spinnerColor: 'green' },
+    { instance: chalk.red, spinnerColor: 'red' },
+    { instance: chalk.redBright, spinnerColor: 'red' },
+    { instance: chalk.cyan, spinnerColor: 'cyan' },
+    { instance: chalk.cyanBright, spinnerColor: 'cyan' },
+    { instance: chalk.yellow, spinnerColor: 'yellow' },
+    { instance: chalk.yellowBright, spinnerColor: 'yellow' },
+    { instance: chalk.magenta, spinnerColor: 'magenta' },
+    { instance: chalk.magentaBright, spinnerColor: 'magenta' },
+];
+function getColor(projectName) {
+    let code = 0;
+    for (let i = 0; i < projectName.length; ++i) {
+        code += projectName.charCodeAt(i);
+    }
+    const colorIndex = code % colors.length;
+    return colors[colorIndex];
+}

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

@@ -0,0 +1 @@
+export { ReleaseVersionGeneratorSchema } from 'nx/src/command-line/release/version';

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

@@ -0,0 +1,45 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "NxJSReleaseVersionGenerator",
+  "cli": "nx",
+  "title": "Implementation details of `nx release version`",
+  "description": "DO NOT INVOKE DIRECTLY WITH `nx generate`. Use `nx release version` instead.",
+  "type": "object",
+  "properties": {
+    "projects": {
+      "type": "array",
+      "description": "The ProjectGraphProjectNodes being versioned in the current execution.",
+      "items": {
+        "type": "object"
+      }
+    },
+    "projectGraph": {
+      "type": "object",
+      "description": "ProjectGraph instance"
+    },
+    "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."
+    },
+    "preid": {
+      "type": "string",
+      "description": "The optional prerelease identifier to apply to the version, in the case that specifier has been set to prerelease."
+    },
+    "packageRoot": {
+      "type": "string",
+      "description": "The root directory of the directory (containing a manifest file at its root) to publish. Defaults to the project root"
+    },
+    "currentVersionResolver": {
+      "type": "string",
+      "default": "disk",
+      "description": "Which approach to use to determine the current version of the project.",
+      "enum": ["registry", "disk"]
+    },
+    "currentVersionResolverMetadata": {
+      "type": "object",
+      "description": "Additional metadata to pass to the current version resolver.",
+      "default": {}
+    }
+  },
+  "required": ["projects", "projectGraph", "specifier"]
+}

package/src/generators/release-version/test-utils/create-workspace-with-package-dependencies.d.ts

@@ -0,0 +1,16 @@
+import { ProjectGraph, Tree } from '@nx/devkit';
+interface ProjectAndPackageData {
+    [projectName: string]: {
+        projectRoot: string;
+        packageName: string;
+        version: string;
+        packageJsonPath: string;
+        localDependencies: {
+            projectName: string;
+            dependencyCollection: 'dependencies' | 'devDependencies' | 'optionalDependencies';
+            version: string;
+        }[];
+    };
+}
+export declare function createWorkspaceWithPackageDependencies(tree: Tree, projectAndPackageData: ProjectAndPackageData): ProjectGraph;
+export {};

package/src/generators/release-version/test-utils/create-workspace-with-package-dependencies.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWorkspaceWithPackageDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+function createWorkspaceWithPackageDependencies(tree, projectAndPackageData) {
+    const projectGraph = {
+        nodes: {},
+        dependencies: {},
+    };
+    for (const [projectName, data] of Object.entries(projectAndPackageData)) {
+        const packageJsonContents = {
+            name: data.packageName,
+            version: data.version,
+        };
+        for (const dependency of data.localDependencies) {
+            const dependencyPackageName = projectAndPackageData[dependency.projectName].packageName;
+            packageJsonContents[dependency.dependencyCollection] = {
+                ...packageJsonContents[dependency.dependencyCollection],
+                [dependencyPackageName]: dependency.version,
+            };
+        }
+        // add the project and its nx project level dependencies to the projectGraph
+        projectGraph.nodes[projectName] = {
+            name: projectName,
+            type: 'lib',
+            data: {
+                root: data.projectRoot,
+            },
+        };
+        projectGraph.dependencies[projectName] = data.localDependencies.map((dependency) => ({
+            source: projectName,
+            target: dependency.projectName,
+            type: 'static',
+        }));
+        // create the package.json in the tree
+        (0, devkit_1.writeJson)(tree, data.packageJsonPath, packageJsonContents);
+    }
+    return projectGraph;
+}
+exports.createWorkspaceWithPackageDependencies = createWorkspaceWithPackageDependencies;

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

@@ -0,0 +1,12 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+export declare class Package {
+    private packageJson;
+    name: string;
+    version: string;
+    location: string;
+    constructor(packageJson: PackageJson, workspaceRoot: string, workspaceRelativeLocation: string);
+    getLocalDependency(depName: string): {
+        collection: 'dependencies' | 'devDependencies' | 'optionalDependencies';
+        spec: string;
+    } | null;
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Package = void 0;
+const devkit_1 = require("@nx/devkit");
+class Package {
+    constructor(packageJson, workspaceRoot, workspaceRelativeLocation) {
+        this.packageJson = packageJson;
+        this.name = packageJson.name;
+        this.version = packageJson.version;
+        this.location = (0, devkit_1.joinPathFragments)(workspaceRoot, workspaceRelativeLocation);
+    }
+    getLocalDependency(depName) {
+        if (this.packageJson.dependencies?.[depName]) {
+            return {
+                collection: 'dependencies',
+                spec: this.packageJson.dependencies[depName],
+            };
+        }
+        if (this.packageJson.devDependencies?.[depName]) {
+            return {
+                collection: 'devDependencies',
+                spec: this.packageJson.devDependencies[depName],
+            };
+        }
+        if (this.packageJson.optionalDependencies?.[depName]) {
+            return {
+                collection: 'optionalDependencies',
+                spec: this.packageJson.optionalDependencies[depName],
+            };
+        }
+        return null;
+    }
+}
+exports.Package = Package;

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

@@ -0,0 +1,6 @@
+import { ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode, Tree } from '@nx/devkit';
+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 {};

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

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveLocalPackageDependencies = void 0;
+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) {
+    const localPackageDependencies = {};
+    const projectNodeToPackageMap = new Map();
+    // 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;
+        }
+        const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
+        if (!tree.exists(packageJsonPath)) {
+            continue;
+        }
+        const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+        const pkg = new package_1.Package(packageJson, devkit_1.workspaceRoot, packageRoot);
+        projectNodeToPackageMap.set(projectNode, pkg);
+    }
+    // populate local npm package dependencies
+    for (const projectDeps of Object.values(projectGraph.dependencies)) {
+        const workspaceDeps = projectDeps.filter((dep) => !isExternalNpmDependency(dep.target) &&
+            !isExternalNpmDependency(dep.source));
+        for (const dep of workspaceDeps) {
+            const source = projectGraph.nodes[dep.source];
+            const target = projectGraph.nodes[dep.target];
+            if (!source ||
+                !projectNodeToPackageMap.has(source) ||
+                !target ||
+                !projectNodeToPackageMap.has(target)) {
+                // only relevant for dependencies between two workspace projects with Package objects
+                continue;
+            }
+            const sourcePackage = projectNodeToPackageMap.get(source);
+            const targetPackage = projectNodeToPackageMap.get(target);
+            const sourceNpmDependency = sourcePackage.getLocalDependency(targetPackage.name);
+            if (!sourceNpmDependency) {
+                continue;
+            }
+            const targetVersionSpec = (0, resolve_version_spec_1.resolveVersionSpec)(targetPackage.name, targetPackage.version, sourceNpmDependency.spec, sourcePackage.location);
+            const targetMatchesRequirement = 
+            // For file: and workspace: protocols the targetVersionSpec could be a path, so we check if it matches the target's location
+            targetVersionSpec === targetPackage.location ||
+                (0, semver_1.satisfies)(targetPackage.version, targetVersionSpec);
+            if (targetMatchesRequirement) {
+                // track only local package dependencies that are satisfied by the target's version
+                localPackageDependencies[dep.source] = [
+                    ...(localPackageDependencies[dep.source] || []),
+                    {
+                        ...dep,
+                        dependencyCollection: sourceNpmDependency.collection,
+                    },
+                ];
+            }
+        }
+    }
+    return localPackageDependencies;
+}
+exports.resolveLocalPackageDependencies = resolveLocalPackageDependencies;
+function isExternalNpmDependency(dep) {
+    return dep.startsWith('npm:');
+}

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

@@ -0,0 +1 @@
+export declare function resolveVersionSpec(name: string, version: string, spec: string, location?: string): string;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVersionSpec = void 0;
+const npa = require("npm-package-arg");
+function resolveVersionSpec(name, version, spec, location) {
+    // yarn classic uses link instead of file, normalize to match what npm expects
+    spec = spec.replace(/^link:/, 'file:');
+    // Support workspace: protocol for pnpm and yarn 2+ (https://pnpm.io/workspaces#workspace-protocol-workspace)
+    const isWorkspaceSpec = /^workspace:/.test(spec);
+    if (isWorkspaceSpec) {
+        spec = spec.replace(/^workspace:/, '');
+        // replace aliases (https://pnpm.io/workspaces#referencing-workspace-packages-through-aliases)
+        if (spec === '*' || spec === '^' || spec === '~') {
+            if (version) {
+                const prefix = spec === '*' ? '' : spec;
+                spec = `${prefix}${version}`;
+            }
+            else {
+                spec = '*';
+            }
+        }
+    }
+    const npaResult = npa.resolve(name, spec, location);
+    return npaResult.fetchSpec;
+}
+exports.resolveVersionSpec = resolveVersionSpec;

package/src/utils/package-json/update-package-json.js

@@ -15,7 +15,7 @@ const get_main_file_dir_1 = require("../get-main-file-dir");
 function updatePackageJson(options, context, target, dependencies, fileMap = null) {
     let packageJson;
     if (fileMap == null) {
-        fileMap = (0, nx_deps_cache_1.readProjectFileMapCache)()?.projectFileMap || {};
+        fileMap = (0, nx_deps_cache_1.readFileMapCache)()?.fileMap?.projectFileMap || {};
     }
     if (options.updateBuildableProjectDepsInPackageJson) {
         packageJson = (0, create_package_json_1.createPackageJson)(context.projectName, context.projectGraph, {