nx 23.0.0-beta.21 → 23.0.0-beta.23

package/dist/src/plugins/js/utils/register.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NODENEXT_ESM_RESOLVER_SOURCE = void 0;
 exports.forceRegisterEsmLoader = forceRegisterEsmLoader;
+exports.ensureNodeNextEsmResolverRegistered = ensureNodeNextEsmResolverRegistered;
+exports.ensureCjsResolverPatched = ensureCjsResolverPatched;
 exports.isNativeStripPreferred = isNativeStripPreferred;
 exports.registerTsProject = registerTsProject;
 exports.getSwcTranspiler = getSwcTranspiler;
@@ -85,6 +88,195 @@ function ensureEsmLoaderRegistered(opts) {
     module.register(url.pathToFileURL(loaderPath));
     isTsEsmLoaderRegistered = true;
 }
+/**
+ * Source of a minimal ESM resolution hook that rewrites TypeScript NodeNext
+ * `.js`/`.mjs`/`.cjs` relative specifiers to their `.ts`/`.mts`/`.cts` sources.
+ * Inlined as a string so it can be registered as a self-contained `data:`
+ * module - it relies only on Node's default resolver (no ts-node/swc-node) and
+ * defers loading to Node's native TypeScript stripping. The ESM counterpart to
+ * the CJS `ensureCjsResolverPatched`.
+ *
+ * Only rewrites when the default resolution fails with ERR_MODULE_NOT_FOUND,
+ * the importing module is itself TypeScript, and the specifier is relative, so
+ * it never hijacks resolution that would otherwise succeed.
+ *
+ * Exported so the hook can be exercised directly in unit tests.
+ */
+exports.NODENEXT_ESM_RESOLVER_SOURCE = `
+const EXT_FALLBACK = { '.js': ['.ts', '.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'] };
+const TS_PARENT_RE = /\\.(?:ts|tsx|mts|cts)(?:$|\\?)/;
+export async function resolve(specifier, context, nextResolve) {
+  try {
+    return await nextResolve(specifier, context);
+  } catch (err) {
+    if (err?.code !== 'ERR_MODULE_NOT_FOUND') throw err;
+    const parent = context.parentURL;
+    if (!parent || !TS_PARENT_RE.test(parent)) throw err;
+    if (!(specifier.startsWith('./') || specifier.startsWith('../') || specifier.startsWith('file:'))) throw err;
+    const m = specifier.match(/(\\.(?:js|mjs|cjs))($|\\?)/);
+    if (!m) throw err;
+    const fallbacks = EXT_FALLBACK[m[1]];
+    if (!fallbacks) throw err;
+    const base = specifier.slice(0, m.index);
+    const suffix = specifier.slice(m.index + m[1].length);
+    for (const ext of fallbacks) {
+      try { return await nextResolve(base + ext + suffix, context); } catch {}
+    }
+    throw err;
+  }
+}
+`;
+let nodeNextEsmResolverRegistered = false;
+/**
+ * Register a self-contained ESM resolution hook (via `Module.register`) that
+ * rewrites TypeScript NodeNext-style `.js`/`.mjs`/`.cjs` relative specifiers to
+ * their `.ts`/`.mts`/`.cts` sources. This is the ESM counterpart to
+ * `ensureCjsResolverPatched`: Node's native type stripping loads the `.ts`
+ * file, but neither native strip nor Node's ESM resolver rewrites the
+ * extension, so `import './foo.js'` from a `.ts` source where only `foo.ts`
+ * exists fails with ERR_MODULE_NOT_FOUND without it.
+ *
+ * The hook is inlined as a `data:` module (see `NODENEXT_ESM_RESOLVER_SOURCE`)
+ * and relies only on Node's default resolver, so it needs no ts-node/swc-node.
+ *
+ * Idempotent and best-effort: a no-op when `Module.register` is unavailable,
+ * when a TypeScript transpiler is already preloaded (see
+ * `isTsTranspilerPreloaded`), or if registration fails.
+ */
+function ensureNodeNextEsmResolverRegistered() {
+    if (nodeNextEsmResolverRegistered)
+        return;
+    nodeNextEsmResolverRegistered = true;
+    const module = require('node:module');
+    if (typeof module.register !== 'function')
+        return;
+    // Skip when a transpiler was preloaded via `--require`/`--import` (e.g.
+    // `--require ts-node/register`, which Nx uses only when it runs from `.ts`
+    // source). `module.register()` spins up a loader-hook worker thread on which
+    // Node re-runs those preloads, resolved relative to the *current* working
+    // directory - and Nx plugin workers `chdir()` into the analyzed workspace
+    // first. If that workspace can't resolve the preloaded module, the loader
+    // worker throws and can leave module resolution in a bad state, so we must
+    // avoid the call entirely; catching it is not a clean recovery.
+    //
+    // Consequence: in that from-`.ts`-source invocation a `type: module` plugin
+    // using NodeNext `.js` specifiers won't get this resolver (a preloaded
+    // `ts-node` does NOT rewrite `.js` -> `.ts` for ESM). Published Nx is
+    // unaffected - its workers run compiled `.js` with no preload.
+    if (isTsTranspilerPreloaded())
+        return;
+    try {
+        module.register('data:text/javascript,' + encodeURIComponent(exports.NODENEXT_ESM_RESOLVER_SOURCE));
+    }
+    catch {
+        // Best-effort: leave Node's native handling in place for the
+        // dynamic-import path rather than failing the load.
+    }
+}
+/**
+ * Whether this process was started with a TypeScript transpiler preloaded via
+ * a `--require`/`--import`/`--loader` flag (e.g. `--require ts-node/register`),
+ * either directly in `process.execArgv` or through `NODE_OPTIONS`. Used to skip
+ * a redundant ESM loader registration that would otherwise crash a loader-hook
+ * worker re-running the preload from a `chdir()`'d cwd - see
+ * `ensureNodeNextEsmResolverRegistered`.
+ */
+function isTsTranspilerPreloaded() {
+    const PRELOAD_FLAGS = [
+        '-r',
+        '--require',
+        '--import',
+        '--loader',
+        '--experimental-loader',
+    ];
+    const TRANSPILER_RE = /(?:ts-node|@?swc-node)/;
+    // Flags passed directly (e.g. spawn(..., ['--require', 'ts-node/register'])).
+    const execArgv = process.execArgv ?? [];
+    for (let i = 0; i < execArgv.length; i++) {
+        const arg = execArgv[i];
+        const eqIdx = arg.indexOf('=');
+        if (eqIdx !== -1) {
+            if (PRELOAD_FLAGS.includes(arg.slice(0, eqIdx)) &&
+                TRANSPILER_RE.test(arg.slice(eqIdx + 1))) {
+                return true;
+            }
+        }
+        else if (PRELOAD_FLAGS.includes(arg) &&
+            TRANSPILER_RE.test(execArgv[i + 1] ?? '')) {
+            return true;
+        }
+    }
+    // Preloads passed via NODE_OPTIONS don't surface in execArgv.
+    const nodeOptions = process.env.NODE_OPTIONS;
+    if (nodeOptions &&
+        TRANSPILER_RE.test(nodeOptions) &&
+        PRELOAD_FLAGS.some((flag) => nodeOptions.includes(flag))) {
+        return true;
+    }
+    return false;
+}
+let cjsResolverPatched = false;
+/**
+ * Patches Node's CJS resolver to fall back from `.js`/`.mjs`/`.cjs` to the
+ * corresponding TypeScript source extension (`.ts`/`.tsx`, `.mts`, `.cts`)
+ * when the requesting file is itself a `.ts`/`.tsx`/`.mts`/`.cts` source.
+ *
+ * Required for TypeScript NodeNext-style relative imports: `import './foo.js'`
+ * inside a `.ts` file resolves to `./foo.ts` at compile time, but the `.js`
+ * specifier survives transpilation to CJS. Node's native CJS resolver doesn't
+ * rewrite extensions and there is no officially-supported Node API for this —
+ * Node's native strip-types deliberately doesn't either — so a resolver patch
+ * is the prevailing solution in the ecosystem (used by `tsx` and ts-node's
+ * `experimentalResolver`).
+ *
+ * Patches `Module._resolveFilename` (not `_findPath`, matching tsx's narrower
+ * surface). Gates on the requesting file being TS so vanilla `.js` code
+ * requesting missing `.js` files keeps failing — no silent hijack. Only fires
+ * the fallback on `MODULE_NOT_FOUND` so existing `.js` resolution is
+ * unaffected when both files exist. Idempotent on repeat calls.
+ */
+function ensureCjsResolverPatched() {
+    if (cjsResolverPatched)
+        return;
+    cjsResolverPatched = true;
+    const Module = require('node:module');
+    const original = Module._resolveFilename;
+    if (typeof original !== 'function')
+        return;
+    const TS_PARENT_RE = /\.(?:ts|tsx|mts|cts)$/;
+    const EXT_FALLBACK = {
+        '.js': ['.ts', '.tsx'],
+        '.mjs': ['.mts'],
+        '.cjs': ['.cts'],
+    };
+    Module._resolveFilename = function (request, parent, ...rest) {
+        try {
+            return original.call(this, request, parent, ...rest);
+        }
+        catch (err) {
+            if (err?.code !== 'MODULE_NOT_FOUND')
+                throw err;
+            if (!parent?.filename || !TS_PARENT_RE.test(parent.filename))
+                throw err;
+            const match = request.match(/(\.(?:js|mjs|cjs))$/);
+            if (!match)
+                throw err;
+            const fallbacks = EXT_FALLBACK[match[1]];
+            if (!fallbacks)
+                throw err;
+            const base = request.slice(0, -match[1].length);
+            for (const ext of fallbacks) {
+                try {
+                    return original.call(this, base + ext, parent, ...rest);
+                }
+                catch {
+                    // try the next fallback
+                }
+            }
+            throw err;
+        }
+    };
+}
 function tryResolveLoader(specifier) {
     try {
         return require.resolve(specifier);
@@ -194,6 +386,9 @@ function registerTsProject(tsConfigPath) {
     // files goes through a transpiler. No-op if no ESM loader package is
     // installed.
     ensureEsmLoaderRegistered({ required: false });
+    // CJS-side fallback so NodeNext `.js` specifiers in `.ts` sources resolve
+    // to the matching `.ts` file when require()'d.
+    ensureCjsResolverPatched();
     return () => {
         for (const fn of cleanupFunctions) {
             fn();

package/dist/src/plugins/package-json/create-nodes.d.ts

@@ -2,9 +2,9 @@ import { NxJsonConfiguration } from '../../config/nx-json';
 import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PackageJson } from '../../utils/package-json';
 import { PackageManagerCommands } from '../../utils/package-manager';
-import { CreateNodesV2 } from '../../project-graph/plugins';
+import { CreateNodes } from '../../project-graph/plugins';
 import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
-export declare const createNodesV2: CreateNodesV2;
+export declare const createNodes: CreateNodes;
 export declare function buildPackageJsonPatterns(workspaceRoot: string, readJson: (path: string) => any): PackageJsonPatterns;
 type PackageJsonPatterns = {
     positive: string[];

package/dist/src/plugins/package-json/create-nodes.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createNodesV2 = void 0;
+exports.createNodes = void 0;
 exports.buildPackageJsonPatterns = buildPackageJsonPatterns;
 exports.buildPackageJsonWorkspacesMatcher = buildPackageJsonWorkspacesMatcher;
 exports.createNodeFromPackageJson = createNodeFromPackageJson;
@@ -24,7 +24,7 @@ const path_2 = require("path");
 const file_hasher_1 = require("../../hasher/file-hasher");
 const package_json_2 = require("../../../plugins/package-json");
 const globPatterns = (0, globs_1.combineGlobPatterns)('package.json', '**/package.json', 'project.json', '**/project.json');
-exports.createNodesV2 = [
+exports.createNodes = [
     globPatterns,
     (configFiles, _, context) => {
         const { packageJsons, projectJsonRoots } = splitConfigFiles(configFiles);

package/dist/src/plugins/project-json/build-nodes/project-json.d.ts

@@ -1,5 +1,5 @@
 import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
-import { NxPluginV2 } from '../../../project-graph/plugins';
-export declare const ProjectJsonProjectsPlugin: NxPluginV2;
+import { NxPlugin } from '../../../project-graph/plugins';
+export declare const ProjectJsonProjectsPlugin: NxPlugin;
 export default ProjectJsonProjectsPlugin;
 export declare function buildProjectFromProjectJson(json: Partial<ProjectConfiguration>, path: string): ProjectConfiguration;

package/dist/src/plugins/project-json/build-nodes/project-json.js

@@ -7,7 +7,7 @@ const fileutils_1 = require("../../../utils/fileutils");
 const plugins_1 = require("../../../project-graph/plugins");
 exports.ProjectJsonProjectsPlugin = {
     name: 'nx/core/project-json',
-    createNodesV2: [
+    createNodes: [
         '{project.json,**/project.json}',
         (configFiles, _, context) => {
             return (0, plugins_1.createNodesFromFiles)((file) => {

package/dist/src/project-graph/error-types.d.ts

@@ -1,8 +1,8 @@
+import { ProjectGraph } from '../config/project-graph';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { CreateNodesFunction } from './plugins/public-api';
 import { ConfigurationResult } from './utils/project-configuration-utils';
 import type { ConfigurationSourceMaps } from './utils/project-configuration/source-maps';
-import { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { ProjectGraph } from '../config/project-graph';
-import { CreateNodesFunctionV2 } from './plugins/public-api';
 export type ProjectGraphErrorTypes = AggregateCreateNodesError | MergeNodesError | CreateMetadataError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | WorkspaceValidityError;
 export declare class StaleProjectGraphCacheError extends Error {
     constructor();
@@ -18,7 +18,7 @@ export declare class ProjectGraphError extends Error {
      */
     static fromDaemonProjectGraphError(e: DaemonProjectGraphError): ProjectGraphError;
     /**
-     * This gets the partial project graph despite the errors which occured.
+     * This gets the partial project graph despite the errors which occurred.
      * This partial project graph may be missing nodes, properties of nodes, or dependencies.
      * This is useful mostly for visualization/debugging. It should not be used for running tasks.
      */
@@ -61,7 +61,7 @@ export declare function isProjectConfigurationsError(e: unknown): e is ProjectCo
  */
 export declare class AggregateCreateNodesError extends Error {
     readonly errors: Array<[file: string | null, error: Error]>;
-    readonly partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>;
+    readonly partialResults: Awaited<ReturnType<CreateNodesFunction>>;
     pluginIndex: number | undefined;
     /**
      * Throwing this error from a `createNodesV2` function will allow Nx to continue processing and recieve partial results from your plugin.
@@ -88,7 +88,7 @@ export declare class AggregateCreateNodesError extends Error {
      * @param errors An array of tuples that represent errors encountered when processing a given file. An example entry might look like ['path/to/project.json', [Error: 'Invalid JSON. Unexpected token 'a' in JSON at position 0]]
      * @param partialResults The partial results of the `createNodesV2` function. This should be the results for each file that didn't encounter an issue.
      */
-    constructor(errors: Array<[file: string | null, error: Error]>, partialResults: Awaited<ReturnType<CreateNodesFunctionV2>>);
+    constructor(errors: Array<[file: string | null, error: Error]>, partialResults: Awaited<ReturnType<CreateNodesFunction>>);
 }
 export declare function formatAggregateCreateNodesError(error: AggregateCreateNodesError, pluginName: string): void;
 export declare class MergeNodesError extends Error {

package/dist/src/project-graph/error-types.js

@@ -75,7 +75,7 @@ class ProjectGraphError extends Error {
         return new ProjectGraphError(e.errors, e.projectGraph, e.sourceMaps);
     }
     /**
-     * This gets the partial project graph despite the errors which occured.
+     * This gets the partial project graph despite the errors which occurred.
      * This partial project graph may be missing nodes, properties of nodes, or dependencies.
      * This is useful mostly for visualization/debugging. It should not be used for running tasks.
      */

package/dist/src/project-graph/file-utils.d.ts

@@ -13,8 +13,15 @@ export declare class WholeFileChange implements Change {
 export declare class DeletedFileChange implements Change {
     type: string;
 }
+export declare class LockFileChange implements Change {
+    baseContent: string;
+    headContent: string;
+    type: string;
+    constructor(baseContent: string, headContent: string);
+}
 export declare function isWholeFileChange(change: Change): change is WholeFileChange;
 export declare function isDeletedFileChange(change: Change): change is DeletedFileChange;
+export declare function isLockFileChange(change: Change): change is LockFileChange;
 export declare function calculateFileChanges(files: string[], nxArgs?: NxArgs, readFileAtRevision?: {
     (f: string, r: string | void): string;
 }, ignore?: ReturnType<typeof ignore>): FileChange[];

package/dist/src/project-graph/file-utils.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TEN_MEGABYTES = exports.DeletedFileChange = exports.WholeFileChange = void 0;
+exports.TEN_MEGABYTES = exports.LockFileChange = exports.DeletedFileChange = exports.WholeFileChange = void 0;
 exports.isWholeFileChange = isWholeFileChange;
 exports.isDeletedFileChange = isDeletedFileChange;
+exports.isLockFileChange = isLockFileChange;
 exports.calculateFileChanges = calculateFileChanges;
 exports.defaultFileRead = defaultFileRead;
 exports.readPackageJson = readPackageJson;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
+const os_1 = require("os");
 const path_1 = require("path");
 const fileutils_1 = require("../utils/fileutils");
 const ignore_1 = require("../utils/ignore");
@@ -25,16 +27,36 @@ class DeletedFileChange {
     }
 }
 exports.DeletedFileChange = DeletedFileChange;
+class LockFileChange {
+    constructor(baseContent, headContent) {
+        this.baseContent = baseContent;
+        this.headContent = headContent;
+        this.type = 'LockFileChange';
+    }
+}
+exports.LockFileChange = LockFileChange;
 function isWholeFileChange(change) {
     return change.type === 'WholeFileChange';
 }
 function isDeletedFileChange(change) {
     return change.type === 'WholeFileDeleted';
 }
+function isLockFileChange(change) {
+    return change.type === 'LockFileChange';
+}
+const TEXT_LOCK_FILES = new Set([
+    'yarn.lock',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'pnpm-lock.yml',
+    'bun.lock',
+]);
+const BINARY_LOCK_FILES = new Set(['bun.lockb']);
 function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFileAtRevision, ignore = (0, ignore_1.getIgnoreObject)()) {
     files = files.filter((f) => !ignore.ignores(f));
     return files.map((f) => {
         const ext = (0, path_1.extname)(f);
+        const basename = f.split('/').pop() ?? f;
         return {
             file: f,
             getChanges: () => {
@@ -47,6 +69,16 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
                 if (nxArgs.files && nxArgs.files.includes(f)) {
                     return [new WholeFileChange()];
                 }
+                if (TEXT_LOCK_FILES.has(basename) || BINARY_LOCK_FILES.has(basename)) {
+                    try {
+                        const atBase = readLockFileAtRevision(f, basename, nxArgs.base, readFileAtRevision);
+                        const atHead = readLockFileAtRevision(f, basename, nxArgs.head, readFileAtRevision);
+                        return [new LockFileChange(atBase, atHead)];
+                    }
+                    catch {
+                        return [new WholeFileChange()];
+                    }
+                }
                 switch (ext) {
                     case '.json':
                         try {
@@ -75,18 +107,17 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
         };
     });
 }
+function readLockFileAtRevision(file, lockFileName, revision, readFileAtRevision) {
+    if (lockFileName === 'bun.lockb' &&
+        readFileAtRevision === defaultReadFileAtRevision) {
+        return defaultReadBunLockFileAtRevision(file, revision);
+    }
+    return readFileAtRevision(file, revision);
+}
 exports.TEN_MEGABYTES = 1024 * 10000;
 function defaultReadFileAtRevision(file, revision) {
     try {
-        const fileFullPath = `${workspace_root_1.workspaceRoot}${path_1.sep}${file}`;
-        const gitRepositoryPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
-            windowsHide: true,
-        })
-            .toString()
-            .trim();
-        const filePathInGitRepository = (0, path_1.relative)(gitRepositoryPath, fileFullPath)
-            .split(path_1.sep)
-            .join('/');
+        const filePathInGitRepository = getFilePathInGitRepository(file);
         return !revision
             ? (0, fs_1.readFileSync)(file, 'utf-8')
             : (0, child_process_1.execSync)(`git show ${revision}:${filePathInGitRepository}`, {
@@ -101,6 +132,43 @@ function defaultReadFileAtRevision(file, revision) {
         return '';
     }
 }
+function defaultReadBunLockFileAtRevision(file, revision) {
+    if (!revision) {
+        return (0, child_process_1.execFileSync)('bun', [(0, path_1.join)(workspace_root_1.workspaceRoot, file)], {
+            encoding: 'utf-8',
+            maxBuffer: exports.TEN_MEGABYTES,
+            windowsHide: true,
+        }).trim();
+    }
+    const filePathInGitRepository = getFilePathInGitRepository(file);
+    const tempDirectory = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'nx-bun-lock-'));
+    const tempLockfilePath = (0, path_1.join)(tempDirectory, 'bun.lockb');
+    try {
+        const lockFileContents = (0, child_process_1.execFileSync)('git', ['show', `${revision}:${filePathInGitRepository}`], {
+            maxBuffer: exports.TEN_MEGABYTES,
+            stdio: ['pipe', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        (0, fs_1.writeFileSync)(tempLockfilePath, lockFileContents);
+        return (0, child_process_1.execFileSync)('bun', [tempLockfilePath], {
+            encoding: 'utf-8',
+            maxBuffer: exports.TEN_MEGABYTES,
+            windowsHide: true,
+        }).trim();
+    }
+    finally {
+        (0, fs_1.rmSync)(tempDirectory, { force: true, recursive: true });
+    }
+}
+function getFilePathInGitRepository(file) {
+    const fileFullPath = `${workspace_root_1.workspaceRoot}${path_1.sep}${file}`;
+    const gitRepositoryPath = (0, child_process_1.execSync)('git rev-parse --show-toplevel', {
+        windowsHide: true,
+    })
+        .toString()
+        .trim();
+    return (0, path_1.relative)(gitRepositoryPath, fileFullPath).split(path_1.sep).join('/');
+}
 function defaultFileRead(filePath) {
     return (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, filePath), 'utf-8');
 }

package/dist/src/project-graph/plugins/isolation/isolated-plugin.d.ts

@@ -2,7 +2,7 @@ import type { PluginConfiguration } from '../../../config/nx-json';
 import type { ProjectGraph } from '../../../config/project-graph';
 import type { RawProjectGraphDependency } from '../../project-graph-builder';
 import { LoadedNxPlugin } from '../loaded-nx-plugin';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from '../public-api';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, CreateNodesResult, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from '../public-api';
 import type { PluginWorkerLoadResult } from './messaging';
 import { Hook, Phase } from './plugin-lifecycle-manager';
 export type LoadResultPayload = Extract<PluginWorkerLoadResult['payload'], {
@@ -15,7 +15,7 @@ export declare class IsolatedPlugin implements LoadedNxPlugin {
     readonly exclude?: string[];
     readonly createNodes?: [
         filePattern: string,
-        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
+        fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
     ];
     readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
     readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;

package/dist/src/project-graph/plugins/isolation/messaging.d.ts

@@ -3,7 +3,7 @@ import type { Socket } from 'net';
 import type { PluginConfiguration } from '../../../config/nx-json';
 import type { ProjectGraph } from '../../../config/project-graph';
 import type { LoadedNxPlugin } from '../loaded-nx-plugin';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, PostTasksExecutionContext, PreTasksExecutionContext } from '../public-api';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, PostTasksExecutionContext, PreTasksExecutionContext } from '../public-api';
 import type { AllMessages, AllResults, DefineMessages, Handlers, ResultOf, WithResult } from './message-types';
 /**
  * All plugin worker message definitions in one place.
@@ -39,7 +39,7 @@ type PluginMessageDefs = DefineMessages<{
     createNodes: {
         payload: {
             configFiles: string[];
-            context: CreateNodesContextV2;
+            context: CreateNodesContext;
         };
         result: {
             success: true;

package/dist/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -1,7 +1,7 @@
 import type { ProjectGraph } from '../../config/project-graph';
 import { type PluginConfiguration } from '../../config/nx-json';
 import type { RawProjectGraphDependency } from '../project-graph-builder';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContext, CreateNodesResult, NxPlugin, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
 /**
  * NOTE: Avoid using `import type` with this class. It causes issues with
  * jest's module resolution when running tests in projects that import
@@ -12,7 +12,7 @@ export declare class LoadedNxPlugin {
     readonly name: string;
     readonly createNodes?: [
         filePattern: string,
-        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
+        fn: (matchedFiles: string[], context: CreateNodesContext) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
     ];
     readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
     readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
@@ -37,5 +37,5 @@ export declare class LoadedNxPlugin {
      * daemon's process.env automatically.
      */
     setWorkerEnv?(env: Record<string, string>): Promise<void>;
-    constructor(plugin: NxPluginV2, pluginDefinition: PluginConfiguration, index?: number);
+    constructor(plugin: NxPlugin, pluginDefinition: PluginConfiguration, index?: number);
 }

package/dist/src/project-graph/plugins/loaded-nx-plugin.js

@@ -19,12 +19,14 @@ class LoadedNxPlugin {
             this.include = pluginDefinition.include;
             this.exclude = pluginDefinition.exclude;
         }
-        const createNodesV2Impl = plugin.createNodesV2 ?? plugin.createNodes;
-        if (createNodesV2Impl) {
+        // Fall back to `createNodesV2` for plugins authored against the old name.
+        const createNodesImpl = plugin.createNodes ??
+            plugin.createNodesV2;
+        if (createNodesImpl) {
             this.createNodes = [
-                createNodesV2Impl[0],
+                createNodesImpl[0],
                 async (configFiles, context) => {
-                    const result = await createNodesV2Impl[1](configFiles, this.options, context);
+                    const result = await createNodesImpl[1](configFiles, this.options, context);
                     return result.map((r) => [this.name, r[0], r[1]]);
                 },
             ];

package/dist/src/project-graph/plugins/public-api.d.ts

@@ -1,14 +1,26 @@
 import type { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
 import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import type { NxJsonConfiguration } from '../../config/nx-json';
-import type { RawProjectGraphDependency } from '../project-graph-builder';
 import type { TaskResults } from '../../tasks-runner/life-cycle';
-export interface CreateNodesContextV2 {
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+export interface CreateNodesContext {
     readonly nxJsonConfiguration: NxJsonConfiguration;
     readonly workspaceRoot: string;
 }
-export type CreateNodesResultV2 = Array<readonly [configFileSource: string, result: CreateNodesResult]>;
-export type CreateNodesFunctionV2<T = unknown> = (projectConfigurationFiles: readonly string[], options: T | undefined, context: CreateNodesContextV2) => CreateNodesResultV2 | Promise<CreateNodesResultV2>;
+/**
+ * @deprecated This will be removed in Nx 24. See {@link CreateNodesContext}
+ */
+export type CreateNodesContextV2 = CreateNodesContext;
+export type CreateNodesResultArray = Array<readonly [configFileSource: string, result: CreateNodesResult]>;
+/**
+ * @deprecated This will be removed in Nx 24. See {@link CreateNodesResultArray}
+ */
+export type CreateNodesResultV2 = CreateNodesResultArray;
+export type CreateNodesFunction<T = unknown> = (projectConfigurationFiles: readonly string[], options: T | undefined, context: CreateNodesContext) => CreateNodesResultArray | Promise<CreateNodesResultArray>;
+/**
+ * @deprecated see {@link CreateNodesFunction}
+ */
+export type CreateNodesFunctionV2<T = unknown> = CreateNodesFunction<T>;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
@@ -21,13 +33,16 @@ export interface CreateNodesResult {
     externalNodes?: Record<string, ProjectGraphExternalNode>;
 }
 /**
- * A pair of file patterns and {@link CreateNodesFunctionV2}
- * In Nx 21 {@link CreateNodes} will be replaced with this type. In Nx 22, this type will be removed.
+ * A pair of file patterns and {@link CreateNodesFunction}
  */
-export type CreateNodesV2<T = unknown> = readonly [
+export type CreateNodes<T = unknown> = readonly [
     projectFilePattern: string,
-    createNodesFunction: CreateNodesFunctionV2<T>
+    createNodesFunction: CreateNodesFunction<T>
 ];
+/**
+ * @deprecated - use {@link CreateNodes} instead
+ */
+export type CreateNodesV2<T = unknown> = CreateNodes<T>;
 /**
  * Context for {@link CreateDependencies}
  */
@@ -68,18 +83,20 @@ export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | und
 /**
  * A plugin which enhances the behavior of Nx
  */
-export type NxPluginV2<TOptions = unknown> = {
+export type NxPlugin<TOptions = unknown> = {
     name: string;
     /**
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
      */
-    createNodes?: CreateNodesV2<TOptions>;
+    createNodes?: CreateNodes<TOptions>;
     /**
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFiles }
+     *
+     * @deprecated Prefer `createNodes` for new plugins
      */
-    createNodesV2?: CreateNodesV2<TOptions>;
+    createNodesV2?: CreateNodes<TOptions>;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
@@ -116,5 +133,7 @@ export type PreTasksExecution<TOptions = unknown> = (options: TOptions | undefin
 export type PostTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PostTasksExecutionContext) => void | Promise<void>;
 /**
  * A plugin which enhances the behavior of Nx
+ *
+ * @deprecated See {@link NxPlugin}
  */
-export type NxPlugin<TOptions = unknown> = NxPluginV2<TOptions>;
+export type NxPluginV2<TOptions = unknown> = NxPlugin<TOptions>;