@nx/js 16.9.0-beta.0 → 16.9.0-beta.2

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.0",
+  "version": "16.9.0-beta.2",
   "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.0",
-    "@nx/devkit": "16.9.0-beta.0",
-    "@nx/workspace": "16.9.0-beta.0",
+    "@nrwl/js": "16.9.0-beta.2",
+    "@nx/devkit": "16.9.0-beta.2",
+    "@nx/workspace": "16.9.0-beta.2",
     "@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": "822fb12c3f0bbaeb6d4a6fbc6cb1064a291e907f"
+  "gitHead": "e11d538fa2c7266066d554d9405abab8e0a65040"
 }

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,86 @@
+"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 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}`);
+    }
+    // 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);
+        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,5 @@
+export interface PublishExecutorSchema {
+  packageRoot?: string;
+  registry?: string;
+  tag?: string;
+}

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

@@ -0,0 +1,22 @@
+{
+  "$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."
+    }
+  },
+  "required": []
+}

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

@@ -8,6 +8,7 @@ const update_package_json_1 = require("../../utils/package-json/update-package-j
 const tsc_impl_1 = require("./tsc.impl");
 const lib_1 = require("./lib");
 const batch_1 = require("./lib/batch");
+const create_entry_points_1 = require("../../utils/package-json/create-entry-points");
 async function* tscBatchExecutor(taskGraph, inputs, overrides, context) {
     const tasksOptions = (0, batch_1.normalizeTasksOptions)(inputs, context);
     let shouldWatch = false;
@@ -48,7 +49,7 @@ async function* tscBatchExecutor(taskGraph, inputs, overrides, context) {
             taskInfo.assetsHandler.processAllAssetsOnceSync();
             (0, update_package_json_1.updatePackageJson)({
                 ...taskInfo.options,
-                additionalEntryPoints: (0, tsc_impl_1.createEntryPoints)(taskInfo.options, context),
+                additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(taskInfo.options.additionalEntryPoints, context.root),
                 format: [(0, tsc_impl_1.determineModuleFormatFromTsConfig)(tsConfig)],
                 // As long as d.ts files match their .js counterparts, we don't need to emit them.
                 // TSC can match them correctly based on file names.
@@ -72,7 +73,7 @@ async function* tscBatchExecutor(taskGraph, inputs, overrides, context) {
             for (const t of changedTaskInfos) {
                 (0, update_package_json_1.updatePackageJson)({
                     ...t.options,
-                    additionalEntryPoints: (0, tsc_impl_1.createEntryPoints)(t.options, context),
+                    additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(t.options.additionalEntryPoints, context.root),
                     format: [(0, tsc_impl_1.determineModuleFormatFromTsConfig)(t.options.tsConfig)],
                     // As long as d.ts files match their .js counterparts, we don't need to emit them.
                     // TSC can match them correctly based on file names.

package/src/executors/tsc/tsc.impl.d.ts

@@ -4,7 +4,4 @@ import { ExecutorOptions, NormalizedExecutorOptions } from '../../utils/schema';
 export declare function determineModuleFormatFromTsConfig(absolutePathToTsConfig: string): 'cjs' | 'esm';
 export declare function createTypeScriptCompilationOptions(normalizedOptions: NormalizedExecutorOptions, context: ExecutorContext): TypeScriptCompilationOptions;
 export declare function tscExecutor(_options: ExecutorOptions, context: ExecutorContext): AsyncGenerator<import("../../utils/typescript/compile-typescript-files").TypescriptCompilationResult, any, undefined>;
-export declare function createEntryPoints(options: {
-    additionalEntryPoints?: string[];
-}, context: ExecutorContext): string[];
 export default tscExecutor;

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

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEntryPoints = exports.tscExecutor = exports.createTypeScriptCompilationOptions = exports.determineModuleFormatFromTsConfig = void 0;
+exports.tscExecutor = exports.createTypeScriptCompilationOptions = exports.determineModuleFormatFromTsConfig = void 0;
 const ts = require("typescript");
-const fast_glob_1 = require("fast-glob");
 const copy_assets_handler_1 = require("../../utils/assets/copy-assets-handler");
 const check_dependencies_1 = require("../../utils/check-dependencies");
 const compiler_helper_dependency_1 = require("../../utils/compiler-helper-dependency");
@@ -12,6 +11,7 @@ const compile_typescript_files_1 = require("../../utils/typescript/compile-types
 const watch_for_single_file_changes_1 = require("../../utils/watch-for-single-file-changes");
 const lib_1 = require("./lib");
 const ts_config_1 = require("../../utils/typescript/ts-config");
+const create_entry_points_1 = require("../../utils/package-json/create-entry-points");
 function determineModuleFormatFromTsConfig(absolutePathToTsConfig) {
     const tsConfig = (0, ts_config_1.readTsConfig)(absolutePathToTsConfig);
     if (tsConfig.options.module === ts.ModuleKind.ES2015 ||
@@ -64,7 +64,7 @@ async function* tscExecutor(_options, context) {
         await assetHandler.processAllAssetsOnce();
         (0, update_package_json_1.updatePackageJson)({
             ...options,
-            additionalEntryPoints: createEntryPoints(options, context),
+            additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(options.additionalEntryPoints, context.root),
             format: [determineModuleFormatFromTsConfig(options.tsConfig)],
             // As long as d.ts files match their .js counterparts, we don't need to emit them.
             // TSC can match them correctly based on file names.
@@ -76,7 +76,7 @@ async function* tscExecutor(_options, context) {
         const disposeWatchAssetChanges = await assetHandler.watchAndProcessOnAssetChange();
         const disposePackageJsonChanges = await (0, watch_for_single_file_changes_1.watchForSingleFileChanges)(context.projectName, options.projectRoot, 'package.json', () => (0, update_package_json_1.updatePackageJson)({
             ...options,
-            additionalEntryPoints: createEntryPoints(options, context),
+            additionalEntryPoints: (0, create_entry_points_1.createEntryPoints)(options.additionalEntryPoints, context.root),
             // As long as d.ts files match their .js counterparts, we don't need to emit them.
             // TSC can match them correctly based on file names.
             skipTypings: true,
@@ -94,12 +94,4 @@ async function* tscExecutor(_options, context) {
     return yield* typescriptCompilation.iterator;
 }
 exports.tscExecutor = tscExecutor;
-function createEntryPoints(options, context) {
-    if (!options.additionalEntryPoints?.length)
-        return [];
-    return (0, fast_glob_1.sync)(options.additionalEntryPoints, {
-        cwd: context.root,
-    });
-}
-exports.createEntryPoints = createEntryPoints;
 exports.default = tscExecutor;

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/index.d.ts

@@ -10,6 +10,7 @@ export * from './utils/typescript/ast-utils';
 export * from './utils/package-json';
 export * from './utils/assets';
 export * from './utils/package-json/update-package-json';
+export * from './utils/package-json/create-entry-points';
 export { libraryGenerator } from './generators/library/library';
 export { initGenerator } from './generators/init/init';
 export { createLockFile, getLockFileName, } from 'nx/src/plugins/js/lock-file/lock-file';

package/src/index.js

@@ -14,6 +14,7 @@ tslib_1.__exportStar(require("./utils/typescript/ast-utils"), exports);
 tslib_1.__exportStar(require("./utils/package-json"), exports);
 tslib_1.__exportStar(require("./utils/assets"), exports);
 tslib_1.__exportStar(require("./utils/package-json/update-package-json"), exports);
+tslib_1.__exportStar(require("./utils/package-json/create-entry-points"), exports);
 var library_1 = require("./generators/library/library");
 Object.defineProperty(exports, "libraryGenerator", { enumerable: true, get: function () { return library_1.libraryGenerator; } });
 var init_1 = require("./generators/init/init");

package/src/utils/package-json/create-entry-points.d.ts

@@ -0,0 +1 @@
+export declare function createEntryPoints(additionalEntryPoints: undefined | string[], root: string): string[];

package/src/utils/package-json/create-entry-points.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntryPoints = void 0;
+const fast_glob_1 = require("fast-glob");
+const devkit_1 = require("@nx/devkit");
+function createEntryPoints(additionalEntryPoints, root) {
+    if (!additionalEntryPoints?.length)
+        return [];
+    const files = [];
+    // NOTE: calling globSync for each pattern is slower than calling it all at once.
+    // We're doing it this way in order to show a warning for unmatched patterns.
+    // If a pattern is unmatched, it is very likely a mistake by the user.
+    // Performance impact should be negligible since there shouldn't be that many entry points.
+    // Benchmarks show only 1-3% difference in execution time.
+    for (const pattern of additionalEntryPoints) {
+        const matched = (0, fast_glob_1.sync)([pattern], { cwd: root });
+        if (!matched.length)
+            devkit_1.logger.warn(`The pattern ${pattern} did not match any files.`);
+        files.push(...matched);
+    }
+    return files;
+}
+exports.createEntryPoints = createEntryPoints;

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

@@ -8,7 +8,6 @@ const create_package_json_1 = require("nx/src/plugins/js/package-json/create-pac
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
 const fs_extra_1 = require("fs-extra");
-const operators_1 = require("nx/src/project-graph/operators");
 const fileutils_1 = require("nx/src/utils/fileutils");
 const fs_1 = require("fs");
 const nx_deps_cache_1 = require("nx/src/project-graph/nx-deps-cache");
@@ -49,10 +48,16 @@ function updatePackageJson(options, context, target, dependencies, fileMap = nul
     }
 }
 exports.updatePackageJson = updatePackageJson;
-function addMissingDependencies(packageJson, { projectName, targetName, configurationName, root }, dependencies, propType = 'dependencies') {
+function isNpmNode(node, graph) {
+    return !!(graph.externalNodes[node.name]?.type === 'npm');
+}
+function isWorkspaceProject(node, graph) {
+    return !!graph.nodes[node.name];
+}
+function addMissingDependencies(packageJson, { projectName, targetName, configurationName, root, projectGraph, }, dependencies, propType = 'dependencies') {
     const workspacePackageJson = (0, devkit_1.readJsonFile)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'package.json'));
     dependencies.forEach((entry) => {
-        if ((0, operators_1.isNpmProject)(entry.node)) {
+        if (isNpmNode(entry.node, projectGraph)) {
             const { packageName, version } = entry.node.data;
             if (packageJson.dependencies?.[packageName] ||
                 packageJson.devDependencies?.[packageName] ||
@@ -65,7 +70,7 @@ function addMissingDependencies(packageJson, { projectName, targetName, configur
             packageJson[propType] ??= {};
             packageJson[propType][packageName] = version;
         }
-        else {
+        else if (isWorkspaceProject(entry.node, projectGraph)) {
             const packageName = entry.name;
             if (!!workspacePackageJson.devDependencies?.[packageName]) {
                 return;