@nx/js 23.0.0-beta.22 → 23.0.0-beta.24

package/dist/src/executors/release-publish/extract-npm-publish-json-data.js

@@ -8,17 +8,24 @@ const expectedNpmPublishJsonKeys = [
     'size',
     'filename',
 ];
-// Regular expression to match JSON-like objects, including nested objects (which the expected npm publish output will have, e.g. in its "files" array)
-// /{(?:[^{}]|{[^{}]*})*}/g
-// /{                       : Matches the opening brace of a JSON object
-//   (?:              )     : Non-capturing group to apply quantifiers
-//      [^{}]               : Matches any character except for braces
-//           |              : OR
-//            {[^{}]*}      : Matches nested JSON objects
-//                     *    : The non-capturing group (i.e. any character except for braces OR nested JSON objects) can repeat zero or more times
-//                      }   : Matches the closing brace of a JSON object
-//                       /g : Global flag to match all occurrences in the string
-const jsonRegex = /{(?:[^{}]|{[^{}]*})*}/g;
+// Regular expression to match JSON-like objects, including up to two levels of
+// nested objects.
+// /{(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*}/g
+// Two levels of nesting are required to support both shapes of npm/pnpm publish
+// output:
+//   - Older npm (<= 11.13) prints the publish summary as a flat object whose only
+//     nesting is its own "files" array (one level deep).
+//   - Newer npm (>= 11.16, bundled with Node 26) nests that same summary under the
+//     package name, e.g. { "@scope/pkg": { ...id/name/files... } }, adding a
+//     second level. pnpm publish nests the same way when run from the workspace
+//     root. Matching two levels lets us capture the wrapper object in the nested
+//     case so its braces are not left behind in beforeJsonData/afterJsonData.
+const jsonRegex = /{(?:[^{}]|{(?:[^{}]|{[^{}]*})*})*}/g;
+function isNpmPublishSummary(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        expectedNpmPublishJsonKeys.every((key) => value[key] !== undefined));
+}
 function extractNpmPublishJsonData(str) {
     const jsonMatches = str.match(jsonRegex);
     if (jsonMatches) {
@@ -28,21 +35,39 @@ function extractNpmPublishJsonData(str) {
                 continue;
             }
             // Full JSON parsing to identify the JSON object
+            let parsedJson;
             try {
-                const parsedJson = JSON.parse(match);
-                if (!expectedNpmPublishJsonKeys.every((key) => parsedJson[key] !== undefined)) {
-                    continue;
-                }
-                const jsonStartIndex = str.indexOf(match);
-                return {
-                    beforeJsonData: str.slice(0, jsonStartIndex),
-                    jsonData: parsedJson,
-                    afterJsonData: str.slice(jsonStartIndex + match.length),
-                };
+                parsedJson = JSON.parse(match);
             }
             catch {
                 // Ignore parsing errors for unrelated JSON blocks
+                continue;
+            }
+            // npm <= 11.13 emits the summary as a flat object, while npm >= 11.16 (and
+            // pnpm publish run from the workspace root) nest it one level deep under the
+            // package name. Support both by unwrapping a single level when the matched
+            // object isn't itself the summary.
+            let publishData = null;
+            if (isNpmPublishSummary(parsedJson)) {
+                publishData = parsedJson;
+            }
+            else if (typeof parsedJson === 'object' && parsedJson !== null) {
+                for (const value of Object.values(parsedJson)) {
+                    if (isNpmPublishSummary(value)) {
+                        publishData = value;
+                        break;
+                    }
+                }
+            }
+            if (!publishData) {
+                continue;
             }
+            const jsonStartIndex = str.indexOf(match);
+            return {
+                beforeJsonData: str.slice(0, jsonStartIndex),
+                jsonData: publishData,
+                afterJsonData: str.slice(jsonStartIndex + match.length),
+            };
         }
     }
     // No applicable jsonData detected, the whole contents is the beforeJsonData

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.d.ts

@@ -0,0 +1,9 @@
+import { type Tree } from '@nx/devkit';
+export default function migrateCreateNodesV2ToCreateNodes(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+export declare function rewriteCreateNodesV2Imports(source: string, specifiers: ReadonlySet<string>): string;

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = migrateCreateNodesV2ToCreateNodes;
+exports.rewriteCreateNodesV2Imports = rewriteCreateNodesV2Imports;
+const devkit_1 = require("@nx/devkit");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEPRECATED_NAME = 'createNodesV2';
+const CANONICAL_NAME = 'createNodes';
+// Module specifiers from which `@nx/js` publicly exposes `createNodesV2`.
+// A named import or re-export of `createNodesV2` from one of these is rewritten
+// to the canonical `createNodes` export.
+const TARGET_SPECIFIERS = new Set(['@nx/js/typescript']);
+let ts;
+async function migrateCreateNodesV2ToCreateNodes(tree) {
+    let touchedCount = 0;
+    (0, devkit_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes(DEPRECATED_NAME)) {
+            return;
+        }
+        const updated = rewriteCreateNodesV2Imports(original, TARGET_SPECIFIERS);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_1.logger.info(`Renamed \`${DEPRECATED_NAME}\` imports to \`${CANONICAL_NAME}\` in ${touchedCount} file(s).`);
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+/**
+ * Rewrites named imports and re-exports of `createNodesV2` to `createNodes`
+ * when they come from one of the given module specifiers. Only the named
+ * bindings are touched — the module specifier, the `import`/`export` keyword,
+ * any `type` modifier, and any default import are left untouched.
+ */
+function rewriteCreateNodesV2Imports(source, specifiers) {
+    ts ??= (0, devkit_1.ensurePackage)('typescript', '*');
+    const sourceFile = ts.createSourceFile('tmp.ts', source, ts.ScriptTarget.Latest, 
+    /* setParentNodes */ true, ts.ScriptKind.TSX);
+    const changes = [];
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt)) {
+            collectImportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, specifiers, changes);
+        }
+    }
+    return changes.length > 0 ? (0, devkit_1.applyChangesToString)(source, changes) : source;
+}
+function isTargetSpecifier(node, specifiers) {
+    return ts.isStringLiteral(node) && specifiers.has(node.text);
+}
+function collectImportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    const namedBindings = stmt.importClause?.namedBindings;
+    // Only `import { ... }` carries renameable named bindings. `import x`,
+    // `import * as ns`, and side-effect imports reference the module wholesale
+    // and keep working through the `createNodesV2` runtime alias, so we leave
+    // them be. A mixed `import def, { createNodesV2 }` still has its named
+    // bindings rewritten below — the default binding is untouched.
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+}
+function collectExportRewrite(sourceFile, stmt, specifiers, changes) {
+    if (!stmt.moduleSpecifier ||
+        !isTargetSpecifier(stmt.moduleSpecifier, specifiers)) {
+        return;
+    }
+    // `export { ... } from '...'` can be rewritten; `export * from '...'` has no
+    // named bindings to rename.
+    if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, stmt.exportClause, changes);
+}
+/**
+ * Re-renders the `{ ... }` of a named import/export, renaming any
+ * `createNodesV2` specifier to `createNodes`. If renaming would collide with a
+ * `createNodes` that is already present (e.g. `{ createNodes, createNodesV2 }`),
+ * the duplicate is dropped. Returns without recording a change when the binding
+ * list contains no `createNodesV2`.
+ */
+function rewriteNamedBindings(sourceFile, namedBindings, changes) {
+    const elements = namedBindings.elements;
+    const hasDeprecated = elements.some((el) => (el.propertyName ?? el.name).text === DEPRECATED_NAME);
+    if (!hasDeprecated) {
+        return;
+    }
+    const seen = new Set();
+    const rendered = [];
+    for (const el of elements) {
+        const text = renderSpecifier(el);
+        if (!seen.has(text)) {
+            seen.add(text);
+            rendered.push(text);
+        }
+    }
+    const start = namedBindings.getStart(sourceFile);
+    changes.push({
+        type: devkit_1.ChangeType.Delete,
+        start,
+        length: namedBindings.getEnd() - start,
+    }, {
+        type: devkit_1.ChangeType.Insert,
+        index: start,
+        text: `{ ${rendered.join(', ')} }`,
+    });
+}
+function renderSpecifier(el) {
+    const typePrefix = el.isTypeOnly ? 'type ' : '';
+    const rename = (name) => name === DEPRECATED_NAME ? CANONICAL_NAME : name;
+    // `{ name }` — no alias, so the local binding follows the rename.
+    if (!el.propertyName) {
+        return `${typePrefix}${rename(el.name.text)}`;
+    }
+    // `{ propertyName as name }` — only the imported (left) side is renamed; the
+    // local alias is preserved. A now-redundant alias such as
+    // `createNodesV2 as createNodes` collapses to `createNodes`.
+    const canonicalImported = rename(el.propertyName.text);
+    const localName = el.name.text;
+    return canonicalImported === localName
+        ? `${typePrefix}${localName}`
+        : `${typePrefix}${canonicalImported} as ${localName}`;
+}

package/dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md

@@ -0,0 +1,25 @@
+#### Rename `createNodesV2` imports to `createNodes`
+
+`@nx/js` renamed its primary inferred-plugin export from `createNodesV2` to `createNodes`. The `createNodesV2` name is preserved as a deprecated alias for now, but new code should use `createNodes`.
+
+This migration scans every `.ts`, `.tsx`, `.cts`, and `.mts` file in your workspace and rewrites named imports and re-exports of `createNodesV2` from `@nx/js/typescript` to `createNodes`.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts
+import { createNodesV2 } from '@nx/js/typescript';
+```
+
+##### After
+
+```ts
+import { createNodes } from '@nx/js/typescript';
+```
+
+Aliases are preserved (`createNodesV2 as cn` becomes `createNodes as cn`), and if a file already imports both names (`{ createNodes, createNodesV2 }`) the redundant binding is dropped.
+
+#### What is not rewritten
+
+Only static `import`/`export` named bindings from `@nx/js/typescript` are rewritten. Namespace imports, dynamic `import(...)`, `require(...)` destructuring, and property access such as `plugin.createNodesV2` are left untouched — they keep working through the `createNodesV2` runtime alias. Update those by hand if you want to drop the deprecated name everywhere.

package/dist/src/plugins/typescript/plugin.d.ts

@@ -1,4 +1,4 @@
-import { type CreateDependencies, type CreateNodesV2 } from '@nx/devkit';
+import { type CreateDependencies, type CreateNodes } from '@nx/devkit';
 export interface TscPluginOptions {
     compiler?: 'tsc' | 'tsgo';
     typecheck?: boolean | {
@@ -19,5 +19,5 @@ export interface TscPluginOptions {
  */
 export declare const createDependencies: CreateDependencies;
 export declare const PLUGIN_NAME = "@nx/js/typescript";
-export declare const createNodesV2: CreateNodesV2<TscPluginOptions>;
-export declare const createNodes: CreateNodesV2<TscPluginOptions>;
+export declare const createNodesV2: CreateNodes<TscPluginOptions>;
+export declare const createNodes: CreateNodes<TscPluginOptions>;

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

@@ -394,6 +394,12 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
         ts.Extension.Dmts,
         ts.Extension.Mjs,
     ];
+    // A spec is an implicit glob over a directory if its last component has no
+    // extension and no glob characters. TypeScript normalizes the path before
+    // checking its last component, so specs like "." and ".." resolve to a
+    // directory name first.
+    // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9577-L9585
+    const isImplicitGlobSpec = (spec) => !/[.*?]/.test((0, node_path_1.basename)((0, node_path_1.resolve)(absoluteProjectRoot, spec)));
     const normalizeInput = (input, config) => {
         const extensions = config.options.allowJs
             ? [...allSupportedExtensions]
@@ -401,13 +407,9 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
         if (config.options.resolveJsonModule) {
             extensions.push(ts.Extension.Json);
         }
-        const segments = input.split('/');
-        // An "includes" path "foo" is implicitly a glob "foo/**/*" if its last
-        // segment has no extension, and does not contain any glob characters
-        // itself.
-        // https://github.com/microsoft/TypeScript/blob/19b777260b26aac5707b1efd34202054164d4a9d/src/compiler/utilities.ts#L9577-L9585
-        if (!/[.*?]/.test(segments.at(-1))) {
-            return extensions.map((ext) => `${segments.join('/')}/**/*${ext}`);
+        // An "includes" path "foo" is implicitly a glob "foo/**/*"
+        if (isImplicitGlobSpec(input)) {
+            return extensions.map((ext) => `${input}/**/*${ext}`);
         }
         return [input];
     };
@@ -440,6 +442,24 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
                 }
             });
             const normalize = (p) => (p.startsWith('./') ? p.slice(2) : p);
+            // Static (non-glob) prefix of a spec, used for subtree coverage checks.
+            const staticPrefix = (p) => {
+                const segments = normalize(p).split('/');
+                const firstGlobSegment = segments.findIndex((s) => /[*?]/.test(s));
+                return firstGlobSegment === -1
+                    ? segments.join('/')
+                    : segments.slice(0, firstGlobSegment).join('/');
+            };
+            // A non-glob include spec (an implicit directory glob like "." or "src",
+            // or a literal file path) covers an exclude spec if the exclude's static
+            // prefix falls within the include's subtree.
+            const includeCoversExclude = (includePath, excludePath) => {
+                if (/[*?]/.test(includePath)) {
+                    return false;
+                }
+                const rel = (0, node_path_1.relative)((0, node_path_1.resolve)(absoluteProjectRoot, normalize(includePath)), (0, node_path_1.resolve)(absoluteProjectRoot, staticPrefix(excludePath)));
+                return !rel.startsWith('..') && !(0, node_path_1.isAbsolute)(rel);
+            };
             tsconfig.raw.exclude.forEach((e) => {
                 const excludePath = substituteConfigDir(e);
                 const normalizedExclude = normalize(excludePath);
@@ -448,9 +468,14 @@ function getInputs(namedInputs, config, tsConfig, internalProjectReferences, wor
                     const normalizedInclude = normalize(includePath);
                     const includeMatcher = getOrCreateMatcher(normalizedInclude);
                     return (excludeMatcher(normalizedInclude) ||
-                        includeMatcher(normalizedExclude));
+                        includeMatcher(normalizedExclude) ||
+                        includeCoversExclude(includePath, excludePath));
                 })) {
-                    excludePaths.add(excludePath);
+                    // TS treats an implicit-glob exclude like "dist" as excluding the
+                    // whole subtree, so emit it as "dist/**/*".
+                    excludePaths.add(isImplicitGlobSpec(excludePath)
+                        ? `${excludePath}/**/*`
+                        : excludePath);
                 }
             });
         }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureProjectIsIncludedInPluginRegistrations = ensureProjectIsIncludedInPluginRegistrations;
 const devkit_internals_1 = require("nx/src/devkit-internals");
+const picomatch = require("picomatch");
 function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, buildTargetName) {
     nxJson.plugins ??= [];
     let isIncluded = false;
@@ -26,7 +27,13 @@ function ensureProjectIsIncludedInPluginRegistrations(nxJson, projectRoot, build
         }
         else {
             // check if the project would be included by the plugin registration
-            const matchingConfigFiles = (0, devkit_internals_1.findMatchingConfigFiles)([`${projectRoot}/tsconfig.json`], '**/tsconfig.json', registration.include, registration.exclude);
+            // Only consider the tsconfig if the @nx/js/typescript plugin would
+            // actually process it (its path matches the plugin's createNodes glob)
+            // before the registration's include/exclude filters are applied.
+            const tsconfigPath = `${projectRoot}/tsconfig.json`;
+            const matchingConfigFiles = picomatch('**/tsconfig.json', { dot: true })(tsconfigPath)
+                ? (0, devkit_internals_1.findMatchingConfigFiles)([tsconfigPath], registration.include, registration.exclude)
+                : [];
             if (matchingConfigFiles.length) {
                 // it's included by the plugin registration, check if the user-specified options would result
                 // in the appropriate build task being inferred, if not, we need to exclude it

package/dist/src/utils/typescript/ts-config.js

@@ -96,7 +96,7 @@ function resolvePathsBaseUrl(tsconfigPath) {
         const absolute = (0, path_1.resolve)(queue.shift());
         const dir = (0, path_1.dirname)(absolute);
         try {
-            const raw = JSON.parse((0, fs_1.readFileSync)(absolute, 'utf-8'));
+            const raw = (0, devkit_1.readJsonFile)(absolute);
             chain.push({ dir, raw });
             const exts = raw.extends
                 ? Array.isArray(raw.extends)

package/migrations.json

@@ -22,6 +22,12 @@
       "version": "23.0.0-beta.14",
       "description": "Rewrites `@nx/js/src/*` subpath imports to the new `@nx/js/internal` entry. The `./src/*` wildcard has been removed from `@nx/js`'s exports map; `@nx/js/src/release/version-actions` is preserved as a non-wildcard entry for back-compat with existing nx.json release configs. If a rewritten import resolves to a symbol that lives on the public `@nx/js` entry (e.g. `libraryGenerator`, `extractTsConfigBase`, `resolvePathsBaseUrl`), change the specifier to `@nx/js`.",
       "factory": "./dist/src/migrations/update-23-0-0/rewrite-internal-subpath-imports"
+    },
+    "update-23-0-0-migrate-create-nodes-v2-import": {
+      "version": "23.0.0-beta.24",
+      "description": "Rename imports of `createNodesV2` from `@nx/js/typescript` to the canonical `createNodes` export.",
+      "implementation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes",
+      "documentation": "./dist/src/migrations/update-23-0-0/migrate-create-nodes-v2-to-create-nodes.md"
     }
   },
   "packageJsonUpdates": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/js",
-  "version": "23.0.0-beta.22",
+  "version": "23.0.0-beta.24",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -144,11 +144,11 @@
     "source-map-support": "0.5.19",
     "tinyglobby": "^0.2.12",
     "tslib": "^2.3.0",
-    "@nx/devkit": "23.0.0-beta.22",
-    "@nx/workspace": "23.0.0-beta.22"
+    "@nx/workspace": "23.0.0-beta.24",
+    "@nx/devkit": "23.0.0-beta.24"
   },
   "devDependencies": {
-    "nx": "23.0.0-beta.22"
+    "nx": "23.0.0-beta.24"
   },
   "peerDependencies": {
     "@swc/cli": ">=0.6.0 <0.9.0",