@nx/js 18.2.2 → 18.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "18.2.2",
+  "version": "18.2.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": {
@@ -57,9 +57,9 @@
     "semver": "^7.5.3",
     "source-map-support": "0.5.19",
     "tslib": "^2.3.0",
-    "@nx/devkit": "18.2.2",
-    "@nx/workspace": "18.2.2",
-    "@nrwl/js": "18.2.2"
+    "@nx/devkit": "18.2.3",
+    "@nx/workspace": "18.2.3",
+    "@nrwl/js": "18.2.3"
   },
   "peerDependencies": {
     "verdaccio": "^5.0.4"

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

@@ -112,8 +112,14 @@ async function* nodeExecutor(options, context) {
                             if (options.watch && !task.killed) {
                                 devkit_1.logger.info(`NX Process exited with code ${code}, waiting for changes to restart...`);
                             }
-                            if (!options.watch)
-                                done();
+                            if (!options.watch) {
+                                if (code !== 0) {
+                                    error(new Error(`Process exited with code ${code}`));
+                                }
+                                else {
+                                    done();
+                                }
+                            }
                             resolve();
                         });
                         next({ success: true, options: buildOptions });

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

@@ -3,6 +3,8 @@ 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 path_1 = require("path");
+const npm_config_1 = require("../../utils/npm-config");
 const log_tar_1 = require("./log-tar");
 const chalk = require("chalk");
 const LARGE_BUFFER = 1024 * 1000000;
@@ -23,40 +25,36 @@ async function runExecutor(options, context) {
      */
     const isDryRun = process.env.NX_DRY_RUN === 'true' || options.dryRun || false;
     const projectConfig = context.projectsConfigurations.projects[context.projectName];
-    const packageRoot = (0, devkit_1.joinPathFragments)(context.root, options.packageRoot ?? projectConfig.root);
-    const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
-    const projectPackageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
-    const packageName = projectPackageJson.name;
+    const packageRoot = (0, path_1.join)(context.root, options.packageRoot ?? projectConfig.root);
+    const packageJsonPath = (0, path_1.join)(packageRoot, 'package.json');
+    const packageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    const packageName = packageJson.name;
     // If package and project name match, we can make log messages terser
     let packageTxt = packageName === context.projectName
         ? `package "${packageName}"`
         : `package "${packageName}" from project "${context.projectName}"`;
-    if (projectPackageJson.private === true) {
+    if (packageJson.private === true) {
         console.warn(`Skipped ${packageTxt}, because it has \`"private": true\` in ${packageJsonPath}`);
         return {
             success: true,
         };
     }
-    const npmPublishCommandSegments = [`npm publish --json`];
+    const warnFn = (message) => {
+        console.log(chalk.keyword('orange')(message));
+    };
+    const { registry, tag, registryConfigKey } = await (0, npm_config_1.parseRegistryOptions)(context.root, {
+        packageRoot,
+        packageJson,
+    }, {
+        registry: options.registry,
+        tag: options.tag,
+    }, warnFn);
     const npmViewCommandSegments = [
-        `npm view ${packageName} versions dist-tags --json`,
+        `npm view ${packageName} versions dist-tags --json --"${registryConfigKey}=${registry}"`,
+    ];
+    const npmDistTagAddCommandSegments = [
+        `npm dist-tag add ${packageName}@${packageJson.version} ${tag} --"${registryConfigKey}=${registry}"`,
     ];
-    if (options.registry) {
-        npmPublishCommandSegments.push(`--registry=${options.registry}`);
-        npmViewCommandSegments.push(`--registry=${options.registry}`);
-    }
-    if (options.tag) {
-        npmPublishCommandSegments.push(`--tag=${options.tag}`);
-    }
-    if (options.otp) {
-        npmPublishCommandSegments.push(`--otp=${options.otp}`);
-    }
-    if (isDryRun) {
-        npmPublishCommandSegments.push(`--dry-run`);
-    }
-    // Resolve values using the `npm config` command so that things like environment variables and `publishConfig`s are accounted for
-    const registry = options.registry ?? (0, child_process_1.execSync)(`npm config get registry`).toString().trim();
-    const tag = options.tag ?? (0, child_process_1.execSync)(`npm config get tag`).toString().trim();
     /**
      * In a dry-run scenario, it is most likely that all commands are being run with dry-run, therefore
      * the most up to date/relevant version might not exist on disk for us to read and make the npm view
@@ -66,11 +64,11 @@ async function runExecutor(options, context) {
      * perform the npm view step, and just show npm publish's dry-run output.
      */
     if (!isDryRun && !options.firstRelease) {
-        const currentVersion = projectPackageJson.version;
+        const currentVersion = packageJson.version;
         try {
             const result = (0, child_process_1.execSync)(npmViewCommandSegments.join(' '), {
                 env: processEnv(true),
-                cwd: packageRoot,
+                cwd: context.root,
                 stdio: ['ignore', 'pipe', 'pipe'],
             });
             const resultJson = JSON.parse(result.toString());
@@ -84,9 +82,9 @@ async function runExecutor(options, context) {
             if (resultJson.versions.includes(currentVersion)) {
                 try {
                     if (!isDryRun) {
-                        (0, child_process_1.execSync)(`npm dist-tag add ${packageName}@${currentVersion} ${tag} --registry=${registry}`, {
+                        (0, child_process_1.execSync)(npmDistTagAddCommandSegments.join(' '), {
                             env: processEnv(true),
-                            cwd: packageRoot,
+                            cwd: context.root,
                             stdio: 'ignore',
                         });
                         console.log(`Added the dist-tag ${tag} to v${currentVersion} for registry ${registry}.\n`);
@@ -148,11 +146,20 @@ async function runExecutor(options, context) {
     if (options.firstRelease && context.isVerbose) {
         console.log('Skipped npm view because --first-release was set');
     }
+    const npmPublishCommandSegments = [
+        `npm publish ${packageRoot} --json --"${registryConfigKey}=${registry}" --tag=${tag}`,
+    ];
+    if (options.otp) {
+        npmPublishCommandSegments.push(`--otp=${options.otp}`);
+    }
+    if (isDryRun) {
+        npmPublishCommandSegments.push(`--dry-run`);
+    }
     try {
         const output = (0, child_process_1.execSync)(npmPublishCommandSegments.join(' '), {
             maxBuffer: LARGE_BUFFER,
             env: processEnv(true),
-            cwd: packageRoot,
+            cwd: context.root,
             stdio: ['ignore', 'pipe', 'pipe'],
         });
         const stdoutData = JSON.parse(output.toString());

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

@@ -13,6 +13,7 @@ const version_1 = require("nx/src/command-line/release/version");
 const utils_1 = require("nx/src/tasks-runner/utils");
 const ora = require("ora");
 const semver_2 = require("semver");
+const npm_config_1 = require("../../utils/npm-config");
 const resolve_local_package_dependencies_1 = require("./utils/resolve-local-package-dependencies");
 const update_lock_file_1 = require("./utils/update-lock-file");
 async function releaseVersionGenerator(tree, options) {
@@ -61,28 +62,37 @@ Valid values are: ${version_1.validReleaseVersionPrefixes
             if (!packageRoot) {
                 throw new Error(`The project "${projectName}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
             }
-            const packageJsonPath = (0, devkit_1.joinPathFragments)(packageRoot, 'package.json');
-            const workspaceRelativePackageJsonPath = (0, node_path_1.relative)(devkit_1.workspaceRoot, packageJsonPath);
+            const packageJsonPath = (0, node_path_1.join)(packageRoot, 'package.json');
             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}.
+                throw new Error(`The project "${projectName}" does not have a package.json available at ${packageJsonPath}.
 
 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;
+            const packageJson = (0, devkit_1.readJson)(tree, packageJsonPath);
+            log(`🔍 Reading data for package "${packageJson.name}" from ${packageJsonPath}`);
+            const { name: packageName, version: currentVersionFromDisk } = packageJson;
             switch (options.currentVersionResolver) {
                 case 'registry': {
                     const metadata = options.currentVersionResolverMetadata;
-                    const registry = metadata?.registry ??
-                        (await getNpmRegistry()) ??
-                        'https://registry.npmjs.org';
-                    const tag = metadata?.tag ?? 'latest';
+                    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: (0, node_path_1.join)(devkit_1.workspaceRoot, packageRoot),
+                        packageJson,
+                    }, {
+                        registry: registryArg,
+                        tag: tagArg,
+                    }, warnFn);
                     /**
                      * If the currentVersionResolver is set to registry, and the projects are not independent, we only want to make the request once for the whole batch of projects.
                      * For independent projects, we need to make a request for each project individually as they will most likely have different versions.
@@ -96,7 +106,7 @@ To fix this you will either need to add a package.json file at that location, or
                         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 --registry=${registry} --tag=${tag}`, (error, stdout, stderr) => {
+                                (0, node_child_process_1.exec)(`npm view ${packageName} version --"${registryConfigKey}=${registry}" --tag=${tag}`, (error, stdout, stderr) => {
                                     if (error) {
                                         return reject(error);
                                     }
@@ -266,16 +276,16 @@ To fix this you will either need to add a package.json file at that location, or
                 newVersion: null, // will stay as null in the final result in the case that no changes are detected
             };
             if (!specifier) {
-                log(`🚫 Skipping versioning "${projectPackageJson.name}" as no changes were detected.`);
+                log(`🚫 Skipping versioning "${packageJson.name}" as no changes were detected.`);
                 continue;
             }
             const newVersion = (0, version_1.deriveNewSemverVersion)(currentVersion, specifier, options.preid);
             versionData[projectName].newVersion = newVersion;
             (0, devkit_1.writeJson)(tree, packageJsonPath, {
-                ...projectPackageJson,
+                ...packageJson,
                 version: newVersion,
             });
-            log(`✍️  New version ${newVersion} written to ${workspaceRelativePackageJsonPath}`);
+            log(`✍️  New version ${newVersion} written to ${packageJsonPath}`);
             if (dependentProjects.length > 0) {
                 log(`✍️  Applying new version ${newVersion} to ${dependentProjects.length} ${dependentProjects.length > 1
                     ? 'packages which depend'
@@ -286,7 +296,7 @@ To fix this you will either need to add a package.json file at that location, or
                 if (!dependentPackageRoot) {
                     throw new Error(`The dependent project "${dependentProject.source}" does not have a packageRoot available. Please report this issue on https://github.com/nrwl/nx`);
                 }
-                (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(dependentPackageRoot, 'package.json'), (json) => {
+                (0, devkit_1.updateJson)(tree, (0, node_path_1.join)(dependentPackageRoot, 'package.json'), (json) => {
                     // Auto (i.e.infer existing) by default
                     let versionPrefix = options.versionPrefix ?? 'auto';
                     // For auto, we infer the prefix based on the current version of the dependent
@@ -374,17 +384,3 @@ function getColor(projectName) {
     const colorIndex = code % colors.length;
     return colors[colorIndex];
 }
-async function getNpmRegistry() {
-    // Must be non-blocking async to allow spinner to render
-    return await new Promise((resolve, reject) => {
-        (0, node_child_process_1.exec)('npm config get registry', (error, stdout, stderr) => {
-            if (error) {
-                return reject(error);
-            }
-            if (stderr) {
-                return reject(stderr);
-            }
-            return resolve(stdout.trim());
-        });
-    });
-}

package/src/utils/buildable-libs-utils.js

@@ -223,7 +223,7 @@ function computeCompilerOptionsPaths(tsConfig, dependencies) {
 }
 exports.computeCompilerOptionsPaths = computeCompilerOptionsPaths;
 function createTmpTsConfig(tsconfigPath, workspaceRoot, projectRoot, dependencies) {
-    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, 'tsconfig.generated.json');
+    const tmpTsConfigPath = (0, path_1.join)(workspaceRoot, 'tmp', projectRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json');
     const parsedTSConfig = readTsConfigWithRemappedPaths(tsconfigPath, tmpTsConfigPath, dependencies);
     process.on('exit', () => cleanupTmpTsConfigFile(tmpTsConfigPath));
     (0, devkit_1.writeJsonFile)(tmpTsConfigPath, parsedTSConfig);

package/src/utils/npm-config.d.ts

@@ -0,0 +1,25 @@
+import { PackageJson } from 'nx/src/utils/package-json';
+export declare function parseRegistryOptions(cwd: string, pkg: {
+    packageRoot: string;
+    packageJson: PackageJson;
+}, options: {
+    registry?: string;
+    tag?: string;
+}, logWarnFn?: (message: string) => void): Promise<{
+    registry: string;
+    tag: string;
+    registryConfigKey: string;
+}>;
+/**
+ * Returns the npm registry that is used for publishing.
+ *
+ * @param scope the scope of the package for which to determine the registry
+ * @param cwd the directory where the npm config should be read from
+ */
+export declare function getNpmRegistry(cwd: string, scope?: string): Promise<string>;
+/**
+ * Returns the npm tag that is used for publishing.
+ *
+ * @param cwd the directory where the npm config should be read from
+ */
+export declare function getNpmTag(cwd: string): Promise<string>;

package/src/utils/npm-config.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNpmTag = exports.getNpmRegistry = exports.parseRegistryOptions = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+async function parseRegistryOptions(cwd, pkg, options, logWarnFn = console.warn) {
+    const npmRcPath = (0, path_1.join)(pkg.packageRoot, '.npmrc');
+    if ((0, fs_1.existsSync)(npmRcPath)) {
+        const relativeNpmRcPath = (0, path_1.relative)(cwd, npmRcPath);
+        logWarnFn(`\nIgnoring .npmrc file detected in the package root: ${relativeNpmRcPath}. Nested .npmrc files are not supported by npm. Only the .npmrc file at the root of the workspace will be used. To customize the registry or tag for specific packages, see https://nx.dev/recipes/nx-release/configure-custom-registries\n`);
+    }
+    const scope = pkg.packageJson.name.startsWith('@')
+        ? pkg.packageJson.name.split('/')[0]
+        : '';
+    // If the package is scoped, then the registry argument that will
+    // correctly override the registry in the .npmrc file must be scoped.
+    const registryConfigKey = scope ? `${scope}:registry` : 'registry';
+    const publishConfigRegistry = pkg.packageJson.publishConfig?.[registryConfigKey];
+    // Even though it won't override the actual registry that's actually used,
+    // the user might think otherwise, so we should still warn if the user has
+    // set a 'registry' in 'publishConfig' for a scoped package.
+    if (publishConfigRegistry || pkg.packageJson.publishConfig?.registry) {
+        const relativePackageJsonPath = (0, path_1.relative)(cwd, (0, path_1.join)(pkg.packageRoot, 'package.json'));
+        if (options.registry) {
+            logWarnFn(`\nRegistry detected in the 'publishConfig' of the package manifest: ${relativePackageJsonPath}. This will override your registry option set in the project configuration or passed via the --registry argument, which is why configuring the registry with 'publishConfig' is not recommended. For details, see https://nx.dev/recipes/nx-release/configure-custom-registries\n`);
+        }
+        else {
+            logWarnFn(`\nRegistry detected in the 'publishConfig' of the package manifest: ${relativePackageJsonPath}. Configuring the registry in this way is not recommended because it prevents the registry from being overridden in project configuration or via the --registry argument. To customize the registry for specific packages, see https://nx.dev/recipes/nx-release/configure-custom-registries\n`);
+        }
+    }
+    const registry = 
+    // `npm publish` will always use the publishConfig registry if it exists, even over the --registry arg
+    publishConfigRegistry ||
+        options.registry ||
+        (await getNpmRegistry(cwd, scope));
+    const tag = options.tag || (await getNpmTag(cwd));
+    return { registry, tag, registryConfigKey };
+}
+exports.parseRegistryOptions = parseRegistryOptions;
+/**
+ * Returns the npm registry that is used for publishing.
+ *
+ * @param scope the scope of the package for which to determine the registry
+ * @param cwd the directory where the npm config should be read from
+ */
+async function getNpmRegistry(cwd, scope) {
+    let registry;
+    if (scope) {
+        registry = await getNpmConfigValue(`${scope}:registry`, cwd);
+    }
+    if (!registry) {
+        registry = await getNpmConfigValue('registry', cwd);
+    }
+    return registry;
+}
+exports.getNpmRegistry = getNpmRegistry;
+/**
+ * Returns the npm tag that is used for publishing.
+ *
+ * @param cwd the directory where the npm config should be read from
+ */
+async function getNpmTag(cwd) {
+    // npm does not support '@scope:tag' in the npm config, so we only need to check for 'tag'.
+    return getNpmConfigValue('tag', cwd);
+}
+exports.getNpmTag = getNpmTag;
+async function getNpmConfigValue(key, cwd) {
+    try {
+        const result = await execAsync(`npm config get ${key}`, cwd);
+        return result === 'undefined' ? undefined : result;
+    }
+    catch (e) {
+        return Promise.resolve(undefined);
+    }
+}
+async function execAsync(command, cwd) {
+    // Must be non-blocking async to allow spinner to render
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(command, { cwd }, (error, stdout, stderr) => {
+            if (error) {
+                return reject(error);
+            }
+            if (stderr) {
+                return reject(stderr);
+            }
+            return resolve(stdout.trim());
+        });
+    });
+}