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

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

@@ -39,6 +39,19 @@ function isAlreadyPublishedPublishError(stdoutData, stderr = '', stdout = '') {
         (error?.code === 'E409' &&
             errorMessage.includes('this package is already present')));
 }
+function isNpmViewNotFoundError(err) {
+    if (err.code === 'ENOBUFS' || err.signal) {
+        return false;
+    }
+    try {
+        const errorCode = JSON.parse(err.stdout?.toString() || '{}').error?.code;
+        if (errorCode) {
+            return errorCode === 'E404';
+        }
+    }
+    catch { }
+    return /(?:^|\n)npm (?:ERR!|error) code E404(?:\n|$)/i.test(err.stderr?.toString() || '');
+}
 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)
@@ -146,10 +159,11 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
     }, warnFn);
     // 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 npmViewDistTagField = `dist-tags[${tag}]`;
     const npmViewCommandSegments = pm === 'bun'
         ? ['bun info', packageName, `--json --"${registryConfigKey}=${registry}"`]
         : [
-            `npm view ${packageName} versions dist-tags --json --"${registryConfigKey}=${registry}"`,
+            `npm view ${packageName}@${packageJson.version} name version "${npmViewDistTagField}" --json --"${registryConfigKey}=${registry}"`,
         ];
     const npmDistTagAddCommandSegments = [
         `npm dist-tag add ${packageName}@${packageJson.version} ${tag} --"${registryConfigKey}=${registry}"`,
@@ -171,20 +185,47 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
                 stdio: ['ignore', 'pipe', 'pipe'],
                 windowsHide: true,
             });
-            const resultJson = JSON.parse(result.toString());
-            const distTags = resultJson['dist-tags'] || {};
-            if (distTags[tag] === currentVersion) {
+            // `npm view`/`bun info` can exit 0 with empty stdout when the package exists in the registry but has
+            // no published versions or dist-tags yet (e.g. GitHub packages). Treat empty output the same as
+            // package not existing yet and continue to the publish step.
+            const output = result.toString().trim();
+            let distTagVersion;
+            let versionExists;
+            if (!output) {
+                versionExists = false;
+            }
+            else {
+                const resultJson = JSON.parse(output);
+                if (pm === 'bun') {
+                    distTagVersion = resultJson['dist-tags']?.[tag];
+                    versionExists = (Array.isArray(resultJson.versions)
+                        ? resultJson.versions
+                        : [resultJson.versions]).includes(currentVersion);
+                }
+                else {
+                    const metadataEntries = Array.isArray(resultJson)
+                        ? resultJson
+                        : [resultJson];
+                    const currentVersionMetadata = metadataEntries.find((metadata) => metadata?.name === packageName &&
+                        metadata?.version === currentVersion);
+                    if (!currentVersionMetadata) {
+                        console.error(`Something unexpected went wrong when checking for existing dist-tags. The registry returned metadata that did not match ${packageName}@${currentVersion}.`);
+                        return {
+                            success: false,
+                        };
+                    }
+                    distTagVersion = currentVersionMetadata[npmViewDistTagField];
+                    versionExists = true;
+                }
+            }
+            if (distTagVersion === currentVersion) {
                 console.warn(`Skipped ${packageTxt} because v${currentVersion} already exists in ${registry} with tag "${tag}"`);
                 return {
                     success: true,
                 };
             }
             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)) {
+                if (versionExists) {
                     try {
                         if (!isDryRun) {
                             (0, child_process_1.execSync)(npmDistTagAddCommandSegments.join(' '), {
@@ -245,35 +286,15 @@ Please update the local dependency on "${depName}" to be a valid semantic versio
             }
         }
         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?.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,
-                    };
-                }
+            const isNotFound = pm === 'bun'
+                ? [err.stderr?.toString(), err.stdout?.toString()].some((output) => output?.includes('404') &&
+                    output.toLowerCase().includes('not found'))
+                : isNpmViewNotFoundError(err);
+            if (!isNotFound) {
+                console.error(`Something unexpected went wrong when checking for existing dist-tags.\n`, err);
+                return {
+                    success: false,
+                };
             }
         }
     }

package/dist/src/plugins/typescript/plugin.js

@@ -125,6 +125,7 @@ exports.createNodesV2 = [
             configOwners: new Map(),
             projectContexts: new Map(),
             configContexts: new Map(),
+            referenceExpansionCache: new Map(),
         });
         const cache = cacheStore.get(cacheKey);
         initializeTsConfigCache(configFilePaths, context.workspaceRoot, cache);
@@ -701,62 +702,100 @@ function getExternalProjectReferenceTsconfigPatterns(tsConfig, internalProjectRe
             continue;
         }
         visited.add(configPath);
-        const wsRelPath = posixRelative(workspaceRoot, configPath);
-        const tsConfigData = tsConfigCacheData[wsRelPath]?.data;
-        if (!tsConfigData) {
-            continue;
+        const expansion = getReferenceExpansion(configPath, ownerProject, workspaceRoot, cache);
+        // Extended-config patterns follow the traversal's first-visit semantics.
+        for (const extended of expansion.extendedConfigs) {
+            if (visited.has(extended.configPath)) {
+                continue;
+            }
+            uniqueRelPaths.add(extended.pattern);
+            worklist.push({
+                configPath: extended.configPath,
+                ownerProject: extended.ownerProject,
+            });
+        }
+        // Reference patterns are collected even when traversal already visited them.
+        for (const ref of expansion.projectReferences) {
+            if (ref.pattern !== undefined) {
+                uniqueRelPaths.add(ref.pattern);
+            }
+            if (!visited.has(ref.configPath)) {
+                worklist.push({
+                    configPath: ref.configPath,
+                    ownerProject: ref.ownerProject,
+                });
+            }
         }
+    }
+    return Array.from(uniqueRelPaths).map((relPath) => `^{projectRoot}/${relPath}`);
+}
+/**
+ * Returns a config's immediate `extends` and project-reference expansion for
+ * the current owner, caching it for reuse within this invocation. Transitive
+ * traversal, ordering, and visited checks remain with the caller.
+ */
+function getReferenceExpansion(configPath, ownerProject, workspaceRoot, cache) {
+    const configKey = posixRelative(workspaceRoot, configPath);
+    // Reference classification and relative patterns depend on the owner.
+    const ownerKey = ownerProject.normalized;
+    let ownerCache = cache.referenceExpansionCache.get(configKey);
+    const cached = ownerCache?.get(ownerKey);
+    if (cached) {
+        return cached;
+    }
+    const expansion = {
+        extendedConfigs: [],
+        projectReferences: [],
+    };
+    const tsConfigData = tsConfigCacheData[configKey]?.data;
+    if (tsConfigData) {
         // Walk `extends` chains for the visited tsconfig. tsc reads extended
         // configs while resolving project references, so the rel paths must be
         // emitted as inputs. Workspace-root files (no owning project) are skipped
         // — those are covered by the local project's own extends walk.
-        if (tsConfigData.extendedConfigFiles?.length) {
-            for (const extended of tsConfigData.extendedConfigFiles) {
-                if (!extended.filePath || visited.has(extended.filePath)) {
-                    continue;
-                }
-                const extendedWsRelPath = posixRelative(workspaceRoot, extended.filePath);
-                if (!tsConfigCacheData[extendedWsRelPath]) {
-                    continue;
-                }
-                const extendedContext = getConfigContext(extended.filePath, workspaceRoot, cache);
-                if (extendedContext.project.root &&
-                    extendedContext.project.root !== '.') {
-                    uniqueRelPaths.add(posixRelative(extendedContext.project.absolute, extended.filePath));
-                    worklist.push({
-                        configPath: extended.filePath,
-                        ownerProject: extendedContext.project,
-                    });
-                }
+        for (const extended of tsConfigData.extendedConfigFiles ?? []) {
+            if (!extended.filePath) {
+                continue;
+            }
+            const extendedWsRelPath = posixRelative(workspaceRoot, extended.filePath);
+            if (!tsConfigCacheData[extendedWsRelPath]) {
+                continue;
+            }
+            const extendedContext = getConfigContext(extended.filePath, workspaceRoot, cache);
+            if (extendedContext.project.root &&
+                extendedContext.project.root !== '.') {
+                expansion.extendedConfigs.push({
+                    configPath: extended.filePath,
+                    ownerProject: extendedContext.project,
+                    pattern: posixRelative(extendedContext.project.absolute, extended.filePath),
+                });
             }
         }
-        if (!tsConfigData.projectReferences?.length) {
-            continue;
-        }
-        for (const ref of tsConfigData.projectReferences) {
+        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
+            // References absent from the invocation's tsconfig data remain ignored.
             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,
-                });
-            }
+            expansion.projectReferences.push({
+                configPath: refPath,
+                ownerProject: refContext.project,
+                // Only references owned by this project contribute input patterns.
+                pattern: isExternalProjectReference(refContext, ownerProject, workspaceRoot, cache)
+                    ? undefined
+                    : posixRelative(ownerProject.absolute, refPath),
+            });
         }
     }
-    return Array.from(uniqueRelPaths).map((relPath) => `^{projectRoot}/${relPath}`);
+    ownerCache ??= new Map();
+    ownerCache.set(ownerKey, expansion);
+    cache.referenceExpansionCache.set(configKey, ownerCache);
+    return expansion;
 }
 function isExternalProjectReference(refConfig, project, workspaceRoot, cache) {
     const owner = cache.configOwners.get(refConfig.relativePath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.3.0-beta.0",
+  "version": "23.3.0-beta.2",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -147,18 +147,18 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.3.0-beta.0",
-    "@nx/workspace": "23.3.0-beta.0"
+    "@nx/workspace": "23.3.0-beta.2",
+    "@nx/devkit": "23.3.0-beta.2"
   },
   "devDependencies": {
-    "@nx/esbuild": "23.3.0-beta.0",
-    "@nx/eslint": "23.3.0-beta.0",
-    "@nx/jest": "23.3.0-beta.0",
-    "@nx/oxlint": "23.3.0-beta.0",
-    "@nx/rollup": "23.3.0-beta.0",
-    "nx": "23.3.0-beta.0",
-    "@nx/vite": "23.3.0-beta.0",
-    "@nx/vitest": "23.3.0-beta.0"
+    "@nx/jest": "23.3.0-beta.2",
+    "@nx/esbuild": "23.3.0-beta.2",
+    "@nx/eslint": "23.3.0-beta.2",
+    "@nx/oxlint": "23.3.0-beta.2",
+    "@nx/vitest": "23.3.0-beta.2",
+    "@nx/rollup": "23.3.0-beta.2",
+    "nx": "23.3.0-beta.2",
+    "@nx/vite": "23.3.0-beta.2"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",