@nx/js 0.0.0-pr-3-4fa8cf8 → 0.0.0-pr-30418-4f79396

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "0.0.0-pr-3-4fa8cf8",
+  "version": "0.0.0-pr-30418-4f79396",
   "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,8 +39,8 @@
     "@babel/preset-env": "^7.23.2",
     "@babel/preset-typescript": "^7.22.5",
     "@babel/runtime": "^7.22.6",
-    "@nx/devkit": "0.0.0-pr-3-4fa8cf8",
-    "@nx/workspace": "0.0.0-pr-3-4fa8cf8",
+    "@nx/devkit": "0.0.0-pr-30418-4f79396",
+    "@nx/workspace": "0.0.0-pr-30418-4f79396",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",

package/src/generators/library/library.js

@@ -8,8 +8,10 @@ const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project
 const prompt_1 = require("@nx/devkit/src/generators/prompt");
 const target_defaults_utils_1 = require("@nx/devkit/src/generators/target-defaults-utils");
 const log_show_project_command_1 = require("@nx/devkit/src/utils/log-show-project-command");
+const use_legacy_versioning_1 = require("nx/src/command-line/release/config/use-legacy-versioning");
 const path_1 = require("path");
 const generator_prompts_1 = require("../../utils/generator-prompts");
+const sort_fields_1 = require("../../utils/package-json/sort-fields");
 const update_package_json_1 = require("../../utils/package-json/update-package-json");
 const add_swc_config_1 = require("../../utils/swc/add-swc-config");
 const add_swc_dependencies_1 = require("../../utils/swc/add-swc-dependencies");
@@ -21,7 +23,6 @@ const ts_config_1 = require("../../utils/typescript/ts-config");
 const ts_solution_setup_1 = require("../../utils/typescript/ts-solution-setup");
 const versions_1 = require("../../utils/versions");
 const init_1 = require("../init/init");
-const sort_fields_1 = require("../../utils/package-json/sort-fields");
 const add_release_config_1 = require("./utils/add-release-config");
 const defaultOutputDirectory = 'dist';
 async function libraryGenerator(tree, schema) {
@@ -158,8 +159,8 @@ async function libraryGeneratorInternal(tree, schema) {
     return (0, devkit_1.runTasksInSerial)(...tasks);
 }
 async function configureProject(tree, options) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
     if (options.hasPlugin) {
-        const nxJson = (0, devkit_1.readNxJson)(tree);
         (0, plugin_1.ensureProjectIsIncludedInPluginRegistrations)(nxJson, options.projectRoot, options.bundler === 'none' ? null : 'build');
         (0, devkit_1.updateNxJson)(tree, nxJson);
     }
@@ -217,7 +218,7 @@ async function configureProject(tree, options) {
             await (0, add_release_config_1.addReleaseConfigForTsSolution)(tree, options.name, projectConfiguration);
         }
         else {
-            await (0, add_release_config_1.addReleaseConfigForNonTsSolution)(tree, options.name, projectConfiguration, defaultOutputDirectory);
+            await (0, add_release_config_1.addReleaseConfigForNonTsSolution)((0, use_legacy_versioning_1.shouldUseLegacyVersioning)(nxJson.release), tree, options.name, projectConfiguration, defaultOutputDirectory);
         }
     }
     if (!options.useProjectJson) {

package/src/generators/library/utils/add-release-config.d.ts

@@ -7,5 +7,5 @@ export declare function addReleaseConfigForTsSolution(tree: Tree, projectName: s
  * Add release configuration for non-ts solution projects
  * Add release option in project.json and add packageRoot to nx-release-publish target
  */
-export declare function addReleaseConfigForNonTsSolution(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, defaultOutputDirectory?: string): Promise<ProjectConfiguration>;
+export declare function addReleaseConfigForNonTsSolution(useLegacyVersioning: boolean, tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, defaultOutputDirectory?: string): Promise<ProjectConfiguration>;
 export declare function releaseTasks(tree: Tree): Promise<GeneratorCallback>;

package/src/generators/library/utils/add-release-config.js

@@ -91,7 +91,7 @@ async function addReleaseConfigForTsSolution(tree, projectName, projectConfigura
  * Add release configuration for non-ts solution projects
  * Add release option in project.json and add packageRoot to nx-release-publish target
  */
-async function addReleaseConfigForNonTsSolution(tree, projectName, projectConfiguration, defaultOutputDirectory = 'dist') {
+async function addReleaseConfigForNonTsSolution(useLegacyVersioning, tree, projectName, projectConfiguration, defaultOutputDirectory = 'dist') {
     const packageRoot = (0, devkit_1.joinPathFragments)(defaultOutputDirectory, '{projectRoot}');
     projectConfiguration.targets ??= {};
     projectConfiguration.targets['nx-release-publish'] = {
@@ -99,17 +99,31 @@ async function addReleaseConfigForNonTsSolution(tree, projectName, projectConfig
             packageRoot,
         },
     };
-    projectConfiguration.release = {
-        version: {
-            generatorOptions: {
-                packageRoot,
+    if (useLegacyVersioning) {
+        projectConfiguration.release = {
+            version: {
+                generatorOptions: {
+                    packageRoot,
+                    // using git tags to determine the current version is required here because
+                    // the version in the package root is overridden with every build
+                    currentVersionResolver: 'git-tag',
+                    fallbackCurrentVersionResolver: 'disk',
+                },
+            },
+        };
+    }
+    else {
+        // TODO: re-evaluate this config in new versions
+        projectConfiguration.release = {
+            version: {
+                manifestRootsToUpdate: [packageRoot],
                 // using git tags to determine the current version is required here because
                 // the version in the package root is overridden with every build
                 currentVersionResolver: 'git-tag',
                 fallbackCurrentVersionResolver: 'disk',
             },
-        },
-    };
+        };
+    }
     await addReleaseConfigForTsSolution(tree, projectName, projectConfiguration);
     return projectConfiguration;
 }

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

@@ -666,7 +666,10 @@ To fix this you will either need to add a package.json file at that location, or
                     deletedFiles.push(...(await cb(opts.dryRun)));
                 }
                 const cwd = tree.root;
-                changedFiles.push(...(await (0, update_lock_file_1.updateLockFile)(cwd, opts)));
+                changedFiles.push(...(await (0, update_lock_file_1.updateLockFile)(cwd, {
+                    ...opts,
+                    useLegacyVersioning: true,
+                })));
                 return { changedFiles, deletedFiles };
             },
         };

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

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

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

@@ -8,6 +8,8 @@
   "properties": {
     "projects": {
       "type": "array",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "The ProjectGraphProjectNodes being versioned in the current execution.",
       "items": {
         "type": "object"
@@ -15,16 +17,33 @@
     },
     "projectGraph": {
       "type": "object",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "ProjectGraph instance"
     },
-    "specifier": {
-      "type": "string",
-      "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
-    },
     "releaseGroup": {
       "type": "object",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
       "description": "The resolved release group configuration, including name, relevant to all projects in the current execution."
     },
+    "conventionalCommitsConfig": {
+      "type": "object",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
+      "description": "The conventional commits configuration to use when determining the next version of the project.",
+      "default": {}
+    },
+    "firstRelease": {
+      "type": "boolean",
+      "hidden": true,
+      "$comment": "This is not configured/passed by the user. It is provided by the version command.",
+      "description": "Whether this is the first release of the project (which skips some validation within the generator)."
+    },
+    "specifier": {
+      "type": "string",
+      "description": "Exact version or semver keyword to apply to the selected release group. Overrides specifierSource."
+    },
     "specifierSource": {
       "type": "string",
       "default": "prompt",

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

@@ -1,5 +1,10 @@
-export declare function updateLockFile(cwd: string, { dryRun, verbose, generatorOptions, }: {
+export declare function updateLockFile(cwd: string, { dryRun, verbose, useLegacyVersioning, options, }: {
     dryRun?: boolean;
     verbose?: boolean;
-    generatorOptions?: Record<string, unknown>;
+    useLegacyVersioning?: boolean;
+    options?: {
+        skipLockFileUpdate?: boolean;
+        installArgs?: string;
+        installIgnoreScripts?: boolean;
+    };
 }): Promise<string[]>;

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

@@ -7,8 +7,8 @@ const client_1 = require("nx/src/daemon/client/client");
 // eslint-disable-next-line @typescript-eslint/no-restricted-imports
 const lock_file_1 = require("nx/src/plugins/js/lock-file/lock-file");
 const semver_1 = require("semver");
-async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
-    if (generatorOptions?.skipLockFileUpdate) {
+async function updateLockFile(cwd, { dryRun, verbose, useLegacyVersioning, options, }) {
+    if (options?.skipLockFileUpdate) {
         if (verbose) {
             console.log('\nSkipped lock file update because skipLockFileUpdate was set.');
         }
@@ -36,10 +36,10 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
         await client_1.daemonClient.stop();
     }
     const packageManagerCommands = (0, devkit_1.getPackageManagerCommand)(packageManager);
-    let installArgs = generatorOptions?.installArgs || '';
+    let installArgs = options?.installArgs || '';
     devkit_1.output.logSingleLine(`Updating ${packageManager} lock file`);
     let env = {};
-    if (generatorOptions?.installIgnoreScripts) {
+    if (options?.installIgnoreScripts) {
         if (packageManager === 'yarn') {
             env = { YARN_ENABLE_SCRIPTS: 'false' };
         }
@@ -62,7 +62,7 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
     if (dryRun) {
         return [];
     }
-    execLockFileUpdate(command, cwd, env);
+    execLockFileUpdate(command, cwd, env, useLegacyVersioning);
     if (isDaemonEnabled) {
         try {
             await client_1.daemonClient.startInBackground();
@@ -79,7 +79,7 @@ async function updateLockFile(cwd, { dryRun, verbose, generatorOptions, }) {
     }
     return [lockFile];
 }
-function execLockFileUpdate(command, cwd, env = {}) {
+function execLockFileUpdate(command, cwd, env, useLegacyVersioning) {
     try {
         const LARGE_BUFFER = 1024 * 1000000;
         (0, child_process_1.execSync)(command, {
@@ -93,13 +93,16 @@ function execLockFileUpdate(command, cwd, env = {}) {
         });
     }
     catch (e) {
+        const configPathStart = useLegacyVersioning
+            ? 'release.version.generatorOptions'
+            : 'release.version.versionActionsOptions';
         devkit_1.output.error({
             title: `Error updating lock file with command '${command}'`,
             bodyLines: [
                 `Verify that '${command}' succeeds when run from the workspace root.`,
-                `To configure a string of arguments to be passed to this command, set the 'release.version.generatorOptions.installArgs' property in nx.json.`,
-                `To ignore install lifecycle scripts, set 'release.version.generatorOptions.installIgnoreScripts' to true in nx.json.`,
-                `To disable this step entirely, set 'release.version.generatorOptions.skipLockFileUpdate' to true in nx.json.`,
+                `To configure a string of arguments to be passed to this command, set the '${configPathStart}.installArgs' property in nx.json.`,
+                `To ignore install lifecycle scripts, set '${configPathStart}.installIgnoreScripts' to true in nx.json.`,
+                `To disable this step entirely, set '${configPathStart}.skipLockFileUpdate' to true in nx.json.`,
             ],
         });
         throw e;

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

@@ -0,0 +1,28 @@
+import { ProjectGraph, Tree } from '@nx/devkit';
+import { ManifestData, VersionActions } from 'nx/release';
+import type { NxReleaseVersionV2Configuration } from 'nx/src/config/nx-json';
+export default class JsVersionActions extends VersionActions {
+    manifestFilename: string;
+    static createAfterAllProjectsVersionedCallback(cwd: string, opts: {
+        dryRun?: boolean;
+        verbose?: boolean;
+        versionActionsOptions?: Record<string, unknown>;
+    }): () => Promise<{
+        changedFiles: string[];
+        deletedFiles: any[];
+    }>;
+    readSourceManifestData(tree: Tree): Promise<ManifestData>;
+    readCurrentVersionFromSourceManifest(tree: Tree): Promise<string>;
+    readCurrentVersionFromRegistry(tree: Tree, currentVersionResolverMetadata: NxReleaseVersionV2Configuration['currentVersionResolverMetadata']): Promise<{
+        currentVersion: string;
+        logText: string;
+    }>;
+    getCurrentVersionOfDependency(tree: Tree, projectGraph: ProjectGraph, dependencyProjectName: string): Promise<{
+        currentVersion: string | null;
+        dependencyCollection: string | null;
+    }>;
+    isLocalDependencyProtocol(versionSpecifier: string): boolean;
+    writeVersionToManifests(tree: Tree, newVersion: string): Promise<void>;
+    updateDependencies(tree: Tree, projectGraph: ProjectGraph, dependenciesToUpdate: Record<string, string>): Promise<void>;
+    private parseDependencies;
+}

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

@@ -0,0 +1,213 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = require("node:path");
+const release_1 = require("nx/release");
+const npm_config_1 = require("../../utils/npm-config");
+const resolve_version_spec_1 = require("./utils/resolve-version-spec");
+const update_lock_file_1 = require("./utils/update-lock-file");
+const chalk = require("chalk");
+// Cache at the module level to avoid re-detecting the package manager for each instance
+let pm;
+class JsVersionActions extends release_1.VersionActions {
+    constructor() {
+        super(...arguments);
+        this.manifestFilename = 'package.json';
+    }
+    static createAfterAllProjectsVersionedCallback(cwd, opts) {
+        return async () => {
+            return {
+                changedFiles: await (0, update_lock_file_1.updateLockFile)(cwd, {
+                    ...opts,
+                    useLegacyVersioning: false,
+                }),
+                deletedFiles: [],
+            };
+        };
+    }
+    async readSourceManifestData(tree) {
+        const sourcePackageJsonPath = this.getSourceManifestPath();
+        try {
+            const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+            const dependencies = this.parseDependencies(packageJson);
+            return {
+                name: packageJson.name,
+                currentVersion: packageJson.version,
+                dependencies,
+            };
+        }
+        catch {
+            throw new Error(`Unable to read the package.json file at ${sourcePackageJsonPath}, please ensure that the file exists and is valid`);
+        }
+    }
+    async readCurrentVersionFromSourceManifest(tree) {
+        const sourcePackageJsonPath = this.getSourceManifestPath();
+        try {
+            const packageJson = (0, devkit_1.readJson)(tree, sourcePackageJsonPath);
+            return packageJson.version;
+        }
+        catch {
+            throw new Error(`Unable to determine the current version for project "${this.projectGraphNode.name}" from ${sourcePackageJsonPath}, please ensure that the "version" field is set within the package.json file`);
+        }
+    }
+    async readCurrentVersionFromRegistry(tree, currentVersionResolverMetadata) {
+        const sourceManifestPath = this.getSourceManifestPath();
+        const sourceManifestRoot = (0, node_path_1.dirname)(sourceManifestPath);
+        const packageJson = (0, devkit_1.readJson)(tree, sourceManifestPath);
+        const packageName = packageJson.name;
+        const metadata = currentVersionResolverMetadata;
+        const registryArg = typeof metadata?.registry === 'string' ? metadata.registry : undefined;
+        const tagArg = typeof metadata?.tag === 'string' ? metadata.tag : undefined;
+        const warnFn = (message) => {
+            console.log(chalk.keyword('orange')(message));
+        };
+        const { registry, tag, registryConfigKey } = await (0, npm_config_1.parseRegistryOptions)(devkit_1.workspaceRoot, {
+            packageRoot: sourceManifestRoot,
+            packageJson,
+        }, {
+            registry: registryArg,
+            tag: tagArg,
+        }, warnFn);
+        let currentVersion = null;
+        try {
+            // Must be non-blocking async to allow spinner to render
+            currentVersion = await new Promise((resolve, reject) => {
+                (0, node_child_process_1.exec)(`npm view ${packageName} version --"${registryConfigKey}=${registry}" --tag=${tag}`, {
+                    windowsHide: false,
+                }, (error, stdout, stderr) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    if (stderr) {
+                        return reject(stderr);
+                    }
+                    return resolve(stdout.trim());
+                });
+            });
+        }
+        catch { }
+        return {
+            currentVersion,
+            // Make troubleshooting easier by including the registry and tag data in the log text
+            logText: `"${registryConfigKey}=${registry}" tag=${tag}`,
+        };
+    }
+    async getCurrentVersionOfDependency(tree, projectGraph, dependencyProjectName) {
+        const json = (0, devkit_1.readJson)(tree, this.getSourceManifestPath());
+        // Resolve the package name from the project graph metadata, as it may not match the project name
+        const dependencyPackageName = projectGraph.nodes[dependencyProjectName].data.metadata?.js?.packageName;
+        const dependencyTypes = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        let currentVersion = null;
+        let dependencyCollection = null;
+        for (const depType of dependencyTypes) {
+            if (json[depType] && json[depType][dependencyPackageName]) {
+                currentVersion = json[depType][dependencyPackageName];
+                dependencyCollection = depType;
+                break;
+            }
+        }
+        return {
+            currentVersion,
+            dependencyCollection,
+        };
+    }
+    // NOTE: The TODOs were carried over from the original implementation, they are not yet implemented
+    isLocalDependencyProtocol(versionSpecifier) {
+        const localPackageProtocols = [
+            'file:', // all package managers
+            'workspace:', // not npm
+            // TODO: Support portal protocol at the project graph level before enabling here
+            // 'portal:', // modern yarn only
+        ];
+        // Not using a supported local protocol
+        if (!localPackageProtocols.some((protocol) => versionSpecifier.startsWith(protocol))) {
+            return false;
+        }
+        // Supported by all package managers
+        if (versionSpecifier.startsWith('file:')) {
+            return true;
+        }
+        // Determine specific package manager in use
+        if (!pm) {
+            pm = (0, devkit_1.detectPackageManager)();
+            // pmVersion = getPackageManagerVersion(pm);
+        }
+        if (pm === 'npm' && versionSpecifier.startsWith('workspace:')) {
+            throw new Error(`The "workspace:" protocol is not yet supported by npm (https://github.com/npm/rfcs/issues/765). Please ensure you have a valid setup according to your package manager before attempting to release packages.`);
+        }
+        // TODO: Support portal protocol at the project graph level before enabling here
+        // if (
+        //   version.startsWith('portal:') &&
+        //   (pm !== 'yarn' || lt(pmVersion, '2.0.0'))
+        // ) {
+        //   throw new Error(
+        //     `The "portal:" protocol is only supported by yarn@2.0.0 and above. Please ensure you have a valid setup according to your package manager before attempting to release packages.`
+        //   );
+        // }
+        return true;
+    }
+    async writeVersionToManifests(tree, newVersion) {
+        for (const manifestPath of this.manifestsToUpdate) {
+            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
+                json.version = newVersion;
+                return json;
+            });
+        }
+    }
+    async updateDependencies(tree, projectGraph, dependenciesToUpdate) {
+        for (const manifestPath of this.manifestsToUpdate) {
+            (0, devkit_1.updateJson)(tree, manifestPath, (json) => {
+                const dependencyTypes = [
+                    'dependencies',
+                    'devDependencies',
+                    'peerDependencies',
+                    'optionalDependencies',
+                ];
+                for (const depType of dependencyTypes) {
+                    if (json[depType]) {
+                        for (const [dep, version] of Object.entries(dependenciesToUpdate)) {
+                            // Resolve the package name from the project graph metadata, as it may not match the project name
+                            const packageName = projectGraph.nodes[dep].data.metadata?.js?.packageName;
+                            if (!packageName) {
+                                throw new Error(`Unable to determine the package name for project "${dep}" from the project graph metadata, please ensure that the "@nx/js" plugin is installed and the project graph has been built. If the issue persists, please report this issue on https://github.com/nrwl/nx/issues`);
+                            }
+                            if (json[depType][packageName]) {
+                                json[depType][packageName] = version;
+                            }
+                        }
+                    }
+                }
+                return json;
+            });
+        }
+    }
+    parseDependencies(packageJson) {
+        const result = {};
+        const dependencyCollections = [
+            'dependencies',
+            'devDependencies',
+            'peerDependencies',
+            'optionalDependencies',
+        ];
+        for (const depCollection of dependencyCollections) {
+            if (packageJson[depCollection]) {
+                result[depCollection] = {};
+                for (const [dep, spec] of Object.entries(packageJson[depCollection])) {
+                    const resolvedSpec = (0, resolve_version_spec_1.resolveVersionSpec)(dep, packageJson.version, spec, this.projectGraphNode.data.root);
+                    result[depCollection][dep] = {
+                        resolvedVersion: resolvedSpec,
+                        rawVersionSpec: spec,
+                    };
+                }
+            }
+        }
+        return result;
+    }
+}
+exports.default = JsVersionActions;

package/src/plugins/typescript/util.js

@@ -29,7 +29,6 @@ function addBuildAndWatchDepsTargets(workspaceRoot, projectRoot, targets, option
             dependsOn: ['^build'],
         };
         targets[options.watchDepsTargetName ?? 'watch-deps'] = {
-            continuous: true,
             dependsOn: [buildDepsTargetName],
             command: `${pmc.exec} nx watch --projects ${projectName} --includeDependentProjects -- ${pmc.exec} nx ${buildDepsTargetName} ${projectName}`,
         };