@nx/js 22.6.0-pr.34764.c1c3b27 → 22.6.0-pr.34876.039ddae

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "22.6.0-pr.34764.c1c3b27",
+  "version": "22.6.0-pr.34876.039ddae",
   "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": "22.6.0-pr.34764.c1c3b27",
-    "@nx/workspace": "22.6.0-pr.34764.c1c3b27",
+    "@nx/devkit": "22.6.0-pr.34876.039ddae",
+    "@nx/workspace": "22.6.0-pr.34876.039ddae",
     "@zkochan/js-yaml": "0.0.7",
     "babel-plugin-const-enum": "^1.0.1",
     "babel-plugin-macros": "^3.1.0",
@@ -60,7 +60,7 @@
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "nx": "22.6.0-pr.34764.c1c3b27"
+    "nx": "22.6.0-pr.34876.039ddae"
   },
   "peerDependencies": {
     "verdaccio": "^6.0.5"

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

@@ -1 +1 @@
-{"version":3,"file":"release-publish.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/js/src/executors/release-publish/release-publish.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAEhB,MAAM,YAAY,CAAC;AAQpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAiBjD,wBAA8B,WAAW,CACvC,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,eAAe;;GAsYzB"}
+{"version":3,"file":"release-publish.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/js/src/executors/release-publish/release-publish.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,eAAe,EAEhB,MAAM,YAAY,CAAC;AAQpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAiBjD,wBAA8B,WAAW,CACvC,OAAO,EAAE,qBAAqB,EAC9B,OAAO,EAAE,eAAe;;GAkdzB"}

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

@@ -23,6 +23,25 @@ function processEnv(color) {
 }
 async function runExecutor(options, context) {
     const pm = (0, devkit_1.detectPackageManager)();
+    // Check if npm is installed (needed for dist-tag management and as fallback for view command)
+    let isNpmInstalled = false;
+    try {
+        isNpmInstalled =
+            (0, child_process_1.execSync)('npm --version', {
+                encoding: 'utf-8',
+                windowsHide: true,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim() !== '';
+    }
+    catch {
+        // Allow missing npm only when using bun
+        if (pm !== 'bun') {
+            console.error(`npm was not found in the current environment. This is only supported when using \`bun\` as a package manager, but your detected package manager is "${pm}"`);
+            return {
+                success: false,
+            };
+        }
+    }
     /**
      * We need to check both the env var and the option because the executor may have been triggered
      * indirectly via dependsOn, in which case the env var will be set, but the option will not.
@@ -83,6 +102,20 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
             success: true,
         };
     }
+    /**
+     * If version data was provided by the nx release version step, check if this project
+     * actually had a new version resolved. If not (newVersion is null), there is nothing
+     * to publish, so we can skip this project entirely.
+     */
+    if (options.nxReleaseVersionData) {
+        const projectVersionData = options.nxReleaseVersionData[context.projectName];
+        if (projectVersionData && projectVersionData.newVersion === null) {
+            console.warn(`Skipped ${packageTxt}, because no new version was resolved for this project`);
+            return {
+                success: true,
+            };
+        }
+    }
     const warnFn = (message) => {
         console.log(chalk.keyword('orange')(message));
     };
@@ -93,9 +126,13 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
         registry: options.registry,
         tag: options.tag,
     }, warnFn);
-    const npmViewCommandSegments = [
-        `npm view ${packageName} versions dist-tags --json --"${registryConfigKey}=${registry}"`,
-    ];
+    // Use bun info when bun is the package manager, otherwise use npm view
+    // (npm view works across npm/pnpm/yarn environments and is the established default)
+    const npmViewCommandSegments = pm === 'bun'
+        ? ['bun info', packageName, `--json --"${registryConfigKey}=${registry}"`]
+        : [
+            `npm view ${packageName} versions dist-tags --json --"${registryConfigKey}=${registry}"`,
+        ];
     const npmDistTagAddCommandSegments = [
         `npm dist-tag add ${packageName}@${packageJson.version} ${tag} --"${registryConfigKey}=${registry}"`,
     ];
@@ -124,80 +161,101 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
                     success: true,
                 };
             }
-            // If only one version of a package exists in the registry, versions will be a string instead of an array.
-            const versions = Array.isArray(resultJson.versions)
-                ? resultJson.versions
-                : [resultJson.versions];
-            if (versions.includes(currentVersion)) {
-                try {
-                    if (!isDryRun) {
-                        (0, child_process_1.execSync)(npmDistTagAddCommandSegments.join(' '), {
-                            env: processEnv(true),
-                            cwd: context.root,
-                            stdio: 'ignore',
-                            windowsHide: false,
-                        });
-                        console.log(`Added the dist-tag ${tag} to v${currentVersion} for registry ${registry}.\n`);
-                    }
-                    else {
-                        console.log(`Would add the dist-tag ${tag} to v${currentVersion} for registry ${registry}, but ${chalk.keyword('orange')('[dry-run]')} was set.\n`);
-                    }
-                    return {
-                        success: true,
-                    };
-                }
-                catch (err) {
+            if (isNpmInstalled) {
+                // If only one version of a package exists in the registry, versions will be a string instead of an array.
+                const versions = Array.isArray(resultJson.versions)
+                    ? resultJson.versions
+                    : [resultJson.versions];
+                if (versions.includes(currentVersion)) {
                     try {
-                        const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
-                        // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
-                        if (!(stdoutData.error?.code?.includes('E404') &&
-                            stdoutData.error?.summary?.includes('no such package available')) &&
-                            !(err.stderr?.toString().includes('E404') &&
-                                err.stderr?.toString().includes('no such package available'))) {
-                            console.error('npm dist-tag add error:');
-                            // npm returns error.summary and error.detail
-                            if (stdoutData.error?.summary) {
-                                console.error(stdoutData.error.summary);
-                            }
-                            if (stdoutData.error?.detail) {
-                                console.error(stdoutData.error.detail);
-                            }
-                            // pnpm returns error.code and error.message
-                            if (stdoutData.error?.code && !stdoutData.error?.summary) {
-                                console.error(`Error code: ${stdoutData.error.code}`);
-                            }
-                            if (stdoutData.error?.message && !stdoutData.error?.summary) {
-                                console.error(stdoutData.error.message);
-                            }
-                            if (context.isVerbose) {
-                                console.error('npm dist-tag add stdout:');
-                                console.error(JSON.stringify(stdoutData, null, 2));
+                        if (!isDryRun) {
+                            (0, child_process_1.execSync)(npmDistTagAddCommandSegments.join(' '), {
+                                env: processEnv(true),
+                                cwd: context.root,
+                                stdio: 'ignore',
+                                windowsHide: false,
+                            });
+                            console.log(`Added the dist-tag ${tag} to v${currentVersion} for registry ${registry}.\n`);
+                        }
+                        else {
+                            console.log(`Would add the dist-tag ${tag} to v${currentVersion} for registry ${registry}, but ${chalk.keyword('orange')('[dry-run]')} was set.\n`);
+                        }
+                        return {
+                            success: true,
+                        };
+                    }
+                    catch (err) {
+                        try {
+                            const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+                            // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
+                            if (!(stdoutData.error?.code?.includes('E404') &&
+                                stdoutData.error?.summary?.includes('no such package available')) &&
+                                !(err.stderr?.toString().includes('E404') &&
+                                    err.stderr?.toString().includes('no such package available'))) {
+                                console.error('npm dist-tag add error:');
+                                // npm returns error.summary and error.detail
+                                if (stdoutData.error?.summary) {
+                                    console.error(stdoutData.error.summary);
+                                }
+                                if (stdoutData.error?.detail) {
+                                    console.error(stdoutData.error.detail);
+                                }
+                                // pnpm returns error.code and error.message
+                                if (stdoutData.error?.code && !stdoutData.error?.summary) {
+                                    console.error(`Error code: ${stdoutData.error.code}`);
+                                }
+                                if (stdoutData.error?.message && !stdoutData.error?.summary) {
+                                    console.error(stdoutData.error.message);
+                                }
+                                if (context.isVerbose) {
+                                    console.error('npm dist-tag add stdout:');
+                                    console.error(JSON.stringify(stdoutData, null, 2));
+                                }
+                                return {
+                                    success: false,
+                                };
                             }
+                        }
+                        catch (err) {
+                            console.error('Something unexpected went wrong when processing the npm dist-tag add output\n', err);
                             return {
                                 success: false,
                             };
                         }
                     }
-                    catch (err) {
-                        console.error('Something unexpected went wrong when processing the npm dist-tag add output\n', err);
-                        return {
-                            success: false,
-                        };
-                    }
                 }
             }
         }
         catch (err) {
-            const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
-            // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
-            if (!(stdoutData.error?.code?.includes('E404') &&
-                stdoutData.error?.summary?.toLowerCase().includes('not found')) &&
-                !(err.stderr?.toString().includes('E404') &&
-                    err.stderr?.toString().toLowerCase().includes('not found'))) {
-                console.error(`Something unexpected went wrong when checking for existing dist-tags.\n`, err);
-                return {
-                    success: false,
-                };
+            try {
+                const stdoutData = JSON.parse(err.stdout?.toString() || '{}');
+                // If the error is that the package doesn't exist, then we can ignore it because we will be publishing it for the first time in the next step
+                if (!(stdoutData.error?.code?.includes('E404') &&
+                    stdoutData.error?.summary?.toLowerCase().includes('not found')) &&
+                    !(err.stderr?.toString().includes('E404') &&
+                        err.stderr?.toString().toLowerCase().includes('not found')) &&
+                    // bun uses plain '404' instead of 'E404'
+                    !(err.stderr?.toString().includes('404') &&
+                        err.stderr?.toString().toLowerCase().includes('not found'))) {
+                    console.error(`Something unexpected went wrong when checking for existing dist-tags.\n`, err);
+                    return {
+                        success: false,
+                    };
+                }
+            }
+            catch {
+                // JSON parse failed entirely — check stderr/stdout for plain 404
+                const stderrStr = err.stderr?.toString() || '';
+                const stdoutStr = err.stdout?.toString() || '';
+                if (!((stderrStr.includes('404') &&
+                    stderrStr.toLowerCase().includes('not found')) ||
+                    (stdoutStr.includes('404') &&
+                        stdoutStr.toLowerCase().includes('not found')))) {
+                    console.error(`Something unexpected went wrong when checking for existing dist-tags.\n`, err);
+                    return {
+                        success: false,
+                    };
+                }
             }
         }
     }

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

@@ -6,4 +6,8 @@ export interface PublishExecutorSchema {
   dryRun?: boolean;
   access?: 'public' | 'restricted';
   firstRelease?: boolean;
+  nxReleaseVersionData?: Record<
+    string,
+    { currentVersion: string; newVersion: string | null; [key: string]: any }
+  >;
 }

package/src/plugins/typescript/plugin.js

@@ -456,16 +456,17 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
     if (excludePaths.size) {
         inputs.push(...Array.from(excludePaths).map((p) => `!${pathToInputOrOutput((0, devkit_1.joinPathFragments)(config.project.root, p), workspaceRoot, config.project)}`));
     }
-    if (hasExternalProjectReferences(config.originalPath, tsConfig, workspaceRoot, config.project, cache)) {
-        // tsc --build reads .d.ts and .tsbuildinfo files from referenced projects
-        // https://www.typescriptlang.org/docs/handbook/project-references.html#what-is-a-project-reference
-        inputs.push({
-            dependentTasksOutputFiles: '**/*.{d.ts,tsbuildinfo}',
-        });
-    }
-    else {
-        inputs.push('production' in namedInputs ? '^production' : '^default');
-    }
+    // tsc --build reads .d.ts and .tsbuildinfo files from dependent tasks, not
+    // the source files of dependencies. This correctly tracks build outputs from
+    // both external project references and same-project task dependencies (e.g.
+    // build-native producing .d.ts files that may be excluded from file watching
+    // via .nxignore).
+    inputs.push({
+        dependentTasksOutputFiles: '**/*.{d.ts,tsbuildinfo}',
+        transitive: true,
+    });
+    const externalRefPatterns = getExternalProjectReferenceTsconfigPatterns(tsConfig, internalProjectReferences, workspaceRoot, config.project, cache);
+    inputs.push(...externalRefPatterns);
     // inputs.push({ externalDependencies });
     return inputs;
 }
@@ -617,33 +618,68 @@ function resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, projec
     }
     return projectReferences;
 }
-function hasExternalProjectReferences(tsConfigPath, tsConfig, workspaceRoot, project, cache, seen = new Set()) {
-    if (!tsConfig.projectReferences?.length) {
-        return false;
+/**
+ * Collects unique tsconfig paths (relative to their project root) from the
+ * project reference chain and returns them as `^{projectRoot}/...` input
+ * patterns. We only need to discover the full set of distinct relative paths
+ * from the reference chain.
+ */
+function getExternalProjectReferenceTsconfigPatterns(tsConfig, internalProjectReferences, workspaceRoot, project, cache) {
+    const externalRefs = {};
+    // Collect direct external references from the root tsconfig
+    resolveShallowExternalProjectReferences(tsConfig, workspaceRoot, project, cache, externalRefs);
+    // Collect external references from internal project references
+    for (const refTsConfig of Object.values(internalProjectReferences)) {
+        resolveShallowExternalProjectReferences(refTsConfig, workspaceRoot, project, cache, externalRefs);
+    }
+    // Collect unique tsconfig paths (relative to project root) from the
+    // reference chain, seeded with the external refs.
+    const uniqueRelPaths = new Set();
+    const visited = new Set();
+    const worklist = [];
+    for (const refConfigPath of Object.keys(externalRefs)) {
+        const refContext = getConfigContext(refConfigPath, workspaceRoot, cache);
+        uniqueRelPaths.add(posixRelative(refContext.project.absolute, refConfigPath));
+        worklist.push({
+            configPath: refConfigPath,
+            ownerProject: refContext.project,
+        });
     }
-    seen.add(tsConfigPath);
-    for (const ref of tsConfig.projectReferences) {
-        let refConfigPath = ref.path;
-        if (seen.has(refConfigPath)) {
+    for (let i = 0; i < worklist.length; i++) {
+        const { configPath, ownerProject } = worklist[i];
+        if (visited.has(configPath)) {
             continue;
         }
-        if (!(0, node_fs_1.existsSync)(refConfigPath)) {
+        visited.add(configPath);
+        const wsRelPath = posixRelative(workspaceRoot, configPath);
+        const tsConfigData = tsConfigCacheData[wsRelPath]?.data;
+        if (!tsConfigData?.projectReferences?.length) {
             continue;
         }
-        if (!refConfigPath.endsWith('.json')) {
-            refConfigPath = (0, node_path_1.join)(refConfigPath, 'tsconfig.json');
-        }
-        const refContext = getConfigContext(refConfigPath, workspaceRoot, cache);
-        if (isExternalProjectReference(refContext, project, workspaceRoot, cache)) {
-            return true;
-        }
-        const refTsConfig = retrieveTsConfigFromCache(refConfigPath, workspaceRoot, cache);
-        const result = hasExternalProjectReferences(refConfigPath, refTsConfig, workspaceRoot, project, cache, seen);
-        if (result) {
-            return true;
+        for (const ref of tsConfigData.projectReferences) {
+            let refPath = ref.path;
+            if (!refPath.endsWith('.json')) {
+                refPath = (0, node_path_1.join)(refPath, 'tsconfig.json');
+            }
+            // Skip references not found in the tsconfig cache
+            const refWsRelPath = posixRelative(workspaceRoot, refPath);
+            if (!tsConfigCacheData[refWsRelPath]) {
+                continue;
+            }
+            const refContext = getConfigContext(refPath, workspaceRoot, cache);
+            // Collect paths for references within the same project
+            if (!isExternalProjectReference(refContext, ownerProject, workspaceRoot, cache)) {
+                uniqueRelPaths.add(posixRelative(ownerProject.absolute, refPath));
+            }
+            if (!visited.has(refPath)) {
+                worklist.push({
+                    configPath: refPath,
+                    ownerProject: refContext.project,
+                });
+            }
         }
     }
-    return false;
+    return Array.from(uniqueRelPaths).map((relPath) => `^{projectRoot}/${relPath}`);
 }
 function isExternalProjectReference(refConfig, project, workspaceRoot, cache) {
     const owner = cache.configOwners.get(refConfig.relativePath);