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

package/dist/src/generators/plugin-migrations/executor-to-plugin-migrator.d.ts

@@ -1,5 +1,5 @@
 import type { ProjectConfiguration } from 'nx/src/config/workspace-json-project-json';
-import { type CreateNodesV2, type NxJsonConfiguration, type ProjectGraph, type TargetConfiguration, type Tree } from 'nx/src/devkit-exports';
+import { type CreateNodes, type NxJsonConfiguration, type ProjectGraph, type TargetConfiguration, type Tree } from 'nx/src/devkit-exports';
 import { logger as devkitLogger } from 'nx/src/devkit-exports';
 export type InferredTargetConfiguration = TargetConfiguration & {
     name: string;
@@ -14,14 +14,14 @@ export declare class NoTargetsToMigrateError extends Error {
     constructor();
 }
 export declare function readTargetDefaultsForExecutor(executor: string, targetDefaults: NxJsonConfiguration['targetDefaults'] | undefined): Partial<TargetConfiguration> | undefined;
-export declare function migrateProjectExecutorsToPlugin<T>(tree: Tree, projectGraph: ProjectGraph, pluginPath: string, createNodesV2: CreateNodesV2<T>, defaultPluginOptions: T, migrations: Array<{
+export declare function migrateProjectExecutorsToPlugin<T>(tree: Tree, projectGraph: ProjectGraph, pluginPath: string, createNodesV2: CreateNodes<T>, defaultPluginOptions: T, migrations: Array<{
     executors: string[];
     targetPluginOptionMapper: (targetName: string) => Partial<T>;
     postTargetTransformer: PostTargetTransformer;
     skipProjectFilter?: SkipProjectFilter;
     skipTargetFilter?: SkipTargetFilter;
 }>, specificProjectToMigrate?: string, logger?: typeof devkitLogger): Promise<Map<string, Record<string, string>>>;
-export declare function migrateProjectExecutorsToPluginV1<T>(tree: Tree, projectGraph: ProjectGraph, pluginPath: string, createNodes: CreateNodesV2<T>, defaultPluginOptions: T, migrations: Array<{
+export declare function migrateProjectExecutorsToPluginV1<T>(tree: Tree, projectGraph: ProjectGraph, pluginPath: string, createNodes: CreateNodes<T>, defaultPluginOptions: T, migrations: Array<{
     executors: string[];
     targetPluginOptionMapper: (targetName: string) => Partial<T>;
     postTargetTransformer: PostTargetTransformer;

package/dist/src/generators/target-defaults-utils.js

@@ -7,6 +7,7 @@ exports.addBuildTargetDefaults = addBuildTargetDefaults;
 exports.addE2eCiTargetDefaults = addE2eCiTargetDefaults;
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
+const minimatch_1 = require("minimatch");
 const semver_1 = require("semver");
 const package_json_1 = require("../utils/package-json");
 const normalize_target_defaults_1 = require("../utils/normalize-target-defaults");
@@ -183,7 +184,12 @@ async function addE2eCiTargetDefaults(tree, e2ePlugin, buildTarget, pathToE2ECon
         return;
     }
     const resolvedE2ePlugin = await import(e2ePlugin);
-    const e2ePluginGlob = resolvedE2ePlugin.createNodesV2?.[0] ?? resolvedE2ePlugin.createNodes?.[0];
+    const e2ePluginGlob = resolvedE2ePlugin.createNodes?.[0] ?? resolvedE2ePlugin.createNodesV2?.[0];
+    // The e2e config file must be one this plugin actually processes (its path
+    // matches the plugin's createNodes glob) before the registration's
+    // include/exclude filters are applied.
+    const e2eConfigMatchesPluginGlob = !e2ePluginGlob ||
+        (0, minimatch_1.minimatch)(pathToE2EConfigFile, e2ePluginGlob, { dot: true });
     let foundPluginForApplication;
     for (let i = 0; i < e2ePluginRegistrations.length; i++) {
         let candidatePluginForApplication = e2ePluginRegistrations[i];
@@ -191,7 +197,9 @@ async function addE2eCiTargetDefaults(tree, e2ePlugin, buildTarget, pathToE2ECon
             foundPluginForApplication = candidatePluginForApplication;
             break;
         }
-        const matchingConfigFiles = (0, devkit_internals_1.findMatchingConfigFiles)([pathToE2EConfigFile], e2ePluginGlob, candidatePluginForApplication.include, candidatePluginForApplication.exclude);
+        const matchingConfigFiles = e2eConfigMatchesPluginGlob
+            ? (0, devkit_internals_1.findMatchingConfigFiles)([pathToE2EConfigFile], candidatePluginForApplication.include, candidatePluginForApplication.exclude)
+            : [];
         if (matchingConfigFiles.length) {
             foundPluginForApplication = candidatePluginForApplication;
             break;

package/dist/src/migrations/update-23-0-0/rename-create-nodes-v2-types.d.ts

@@ -0,0 +1,10 @@
+import { type Tree } from 'nx/src/devkit-exports';
+export declare const CREATE_NODES_V2_TYPE_RENAMES: ReadonlyMap<string, string>;
+export default function renameCreateNodesV2Types(tree: Tree): Promise<void>;
+/**
+ * Rewrites named imports and re-exports of the deprecated `*V2` plugin types
+ * from `@nx/devkit` to their canonical names. 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 rewriteCreateNodesV2Types(source: string): string;

package/dist/src/migrations/update-23-0-0/rename-create-nodes-v2-types.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CREATE_NODES_V2_TYPE_RENAMES = void 0;
+exports.default = renameCreateNodesV2Types;
+exports.rewriteCreateNodesV2Types = rewriteCreateNodesV2Types;
+const devkit_exports_1 = require("nx/src/devkit-exports");
+const format_files_1 = require("../../generators/format-files");
+const visit_not_ignored_files_1 = require("../../generators/visit-not-ignored-files");
+const package_json_1 = require("../../utils/package-json");
+const string_change_1 = require("../../utils/string-change");
+const versions_1 = require("../../utils/versions");
+const TS_EXTENSIONS = ['.ts', '.tsx', '.cts', '.mts'];
+const DEVKIT_SPECIFIER = '@nx/devkit';
+// The `*V2` plugin types were renamed to their canonical un-suffixed names in
+// Nx 23. The `V2` names remain as `@deprecated` aliases, so this migration only
+// moves callers onto the canonical names. (`CreateNodesResultV2` is renamed to
+// `CreateNodesResultArray`, not `CreateNodesResult`, which is an unrelated type.)
+exports.CREATE_NODES_V2_TYPE_RENAMES = new Map([
+    ['CreateNodesV2', 'CreateNodes'],
+    ['CreateNodesContextV2', 'CreateNodesContext'],
+    ['CreateNodesResultV2', 'CreateNodesResultArray'],
+    ['CreateNodesFunctionV2', 'CreateNodesFunction'],
+    ['NxPluginV2', 'NxPlugin'],
+]);
+let ts;
+async function renameCreateNodesV2Types(tree) {
+    let touchedCount = 0;
+    (0, visit_not_ignored_files_1.visitNotIgnoredFiles)(tree, '.', (filePath) => {
+        if (!TS_EXTENSIONS.some((ext) => filePath.endsWith(ext))) {
+            return;
+        }
+        const original = tree.read(filePath, 'utf-8');
+        if (!original || !original.includes('V2')) {
+            return;
+        }
+        const updated = rewriteCreateNodesV2Types(original);
+        if (updated !== original) {
+            tree.write(filePath, updated);
+            touchedCount += 1;
+        }
+    });
+    if (touchedCount > 0) {
+        devkit_exports_1.logger.info(`Renamed deprecated CreateNodes V2 type imports from @nx/devkit in ${touchedCount} file(s).`);
+    }
+    await (0, format_files_1.formatFiles)(tree);
+}
+/**
+ * Rewrites named imports and re-exports of the deprecated `*V2` plugin types
+ * from `@nx/devkit` to their canonical names. Only the named bindings are
+ * touched — the module specifier, the `import`/`export` keyword, any `type`
+ * modifier, and any default import are left untouched.
+ */
+function rewriteCreateNodesV2Types(source) {
+    ts ??= (0, package_json_1.ensurePackage)('typescript', versions_1.typescriptVersion);
+    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, changes);
+        }
+        else if (ts.isExportDeclaration(stmt)) {
+            collectExportRewrite(sourceFile, stmt, changes);
+        }
+    }
+    return changes.length > 0 ? (0, string_change_1.applyChangesToString)(source, changes) : source;
+}
+function isDevkitSpecifier(node) {
+    return ts.isStringLiteral(node) && node.text === DEVKIT_SPECIFIER;
+}
+function collectImportRewrite(sourceFile, stmt, changes) {
+    if (!isDevkitSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    const namedBindings = stmt.importClause?.namedBindings;
+    if (!namedBindings || !ts.isNamedImports(namedBindings)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, namedBindings, changes);
+}
+function collectExportRewrite(sourceFile, stmt, changes) {
+    if (!stmt.moduleSpecifier || !isDevkitSpecifier(stmt.moduleSpecifier)) {
+        return;
+    }
+    if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) {
+        return;
+    }
+    rewriteNamedBindings(sourceFile, stmt.exportClause, changes);
+}
+/**
+ * Re-renders the `{ ... }` of a named import/export, renaming any deprecated
+ * `*V2` type to its canonical name. If renaming would collide with a canonical
+ * name that is already present, the duplicate is dropped. Returns without
+ * recording a change when the binding list contains none of the renamed types.
+ */
+function rewriteNamedBindings(sourceFile, namedBindings, changes) {
+    const elements = namedBindings.elements;
+    const hasRenamed = elements.some((el) => exports.CREATE_NODES_V2_TYPE_RENAMES.has((el.propertyName ?? el.name).text));
+    if (!hasRenamed) {
+        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: string_change_1.ChangeType.Delete,
+        start,
+        length: namedBindings.getEnd() - start,
+    }, {
+        type: string_change_1.ChangeType.Insert,
+        index: start,
+        text: `{ ${rendered.join(', ')} }`,
+    });
+}
+function renderSpecifier(el) {
+    const typePrefix = el.isTypeOnly ? 'type ' : '';
+    const rename = (name) => exports.CREATE_NODES_V2_TYPE_RENAMES.get(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/rename-create-nodes-v2-types.md

@@ -0,0 +1,29 @@
+#### Rename deprecated CreateNodes `V2` types from `@nx/devkit`
+
+The canonical plugin API types lost their `V2` suffix in Nx 23. The `V2` names are kept as `@deprecated` aliases, but new code should use the canonical names:
+
+| Deprecated (`@nx/devkit`) | Canonical                |
+| ------------------------- | ------------------------ |
+| `CreateNodesV2`           | `CreateNodes`            |
+| `CreateNodesContextV2`    | `CreateNodesContext`     |
+| `CreateNodesResultV2`     | `CreateNodesResultArray` |
+| `CreateNodesFunctionV2`   | `CreateNodesFunction`    |
+| `NxPluginV2`              | `NxPlugin`               |
+
+This migration scans every `.ts`, `.tsx`, `.cts`, and `.mts` file in your workspace and rewrites named imports and re-exports of these types from `@nx/devkit` to their canonical names.
+
+#### Sample Code Changes
+
+##### Before
+
+```ts
+import type { CreateNodesV2, CreateNodesContextV2 } from '@nx/devkit';
+```
+
+##### After
+
+```ts
+import type { CreateNodes, CreateNodesContext } from '@nx/devkit';
+```
+
+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. The unrelated `CreateNodesResult` type is left untouched.

package/dist/src/utils/add-plugin.d.ts

@@ -1,13 +1,13 @@
-import { CreateNodesV2, ProjectGraph, Tree } from 'nx/src/devkit-exports';
+import { CreateNodes, ProjectGraph, Tree } from 'nx/src/devkit-exports';
 /**
  * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
 
  */
-export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodesV2<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+export declare function addPlugin<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodes<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
 /**
  * @deprecated Use `addPlugin` instead
  * Iterates through various forms of plugin options to find the one which does not conflict with the current graph
 
  */
-export declare function addPluginV1<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodesV2<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
+export declare function addPluginV1<PluginOptions>(tree: Tree, graph: ProjectGraph, pluginName: string, createNodesTuple: CreateNodes<PluginOptions>, options: Partial<Record<keyof PluginOptions, PluginOptions[keyof PluginOptions][]>>, shouldUpdatePackageJsonScripts: boolean): Promise<void>;
 export declare function generateCombinations<T>(input: Record<string, T[]>): Record<string, T>[];

package/dist/src/utils/add-plugin.js

@@ -14,7 +14,7 @@ const devkit_internals_1 = require("nx/src/devkit-internals");
 async function addPlugin(tree, graph, pluginName, createNodesTuple, options, shouldUpdatePackageJsonScripts) {
     return _addPluginInternal(tree, graph, pluginName, (pluginOptions) => new devkit_internals_1.LoadedNxPlugin({
         name: pluginName,
-        createNodesV2: createNodesTuple,
+        createNodes: createNodesTuple,
     }, {
         plugin: pluginName,
         options: pluginOptions,

package/dist/src/utils/calculate-hash-for-create-nodes.d.ts

@@ -1,8 +1,8 @@
-import { CreateNodesContextV2 } from 'nx/src/devkit-exports';
+import { CreateNodesContext } from 'nx/src/devkit-exports';
 /**
  * @deprecated Use {@link calculateHashesForCreateNodes} instead, which batches
  * workspace-context hashing across multiple project roots in a single call.
  * This will be removed in Nx 24.
  */
-export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContextV2, additionalGlobs?: string[]): Promise<string>;
-export declare function calculateHashesForCreateNodes(projectRoots: string[], options: object, context: CreateNodesContextV2, additionalGlobs?: string[][]): Promise<string[]>;
+export declare function calculateHashForCreateNodes(projectRoot: string, options: object, context: CreateNodesContext, additionalGlobs?: string[]): Promise<string>;
+export declare function calculateHashesForCreateNodes(projectRoots: string[], options: object, context: CreateNodesContext, additionalGlobs?: string[][]): Promise<string[]>;

package/dist/src/utils/find-plugin-for-config-file.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findPluginForConfigFile = findPluginForConfigFile;
 const devkit_exports_1 = require("nx/src/devkit-exports");
 const devkit_internals_1 = require("nx/src/devkit-internals");
+const minimatch_1 = require("minimatch");
 async function findPluginForConfigFile(tree, pluginName, pathToConfigFile) {
     const nxJson = (0, devkit_exports_1.readNxJson)(tree);
     if (!nxJson.plugins) {
@@ -18,8 +19,13 @@ async function findPluginForConfigFile(tree, pluginName, pathToConfigFile) {
         }
         if (plugin.include || plugin.exclude) {
             const resolvedPlugin = await import(pluginName);
-            const pluginGlob = resolvedPlugin.createNodesV2?.[0] ?? resolvedPlugin.createNodes?.[0];
-            const matchingConfigFile = (0, devkit_internals_1.findMatchingConfigFiles)([pathToConfigFile], pluginGlob, plugin.include, plugin.exclude);
+            const pluginGlob = resolvedPlugin.createNodes?.[0] ?? resolvedPlugin.createNodesV2?.[0];
+            // The file must be one this plugin actually processes (its path matches
+            // the plugin's createNodes glob) before the registration's include/exclude
+            // filters are applied.
+            const matchingConfigFile = !pluginGlob || (0, minimatch_1.minimatch)(pathToConfigFile, pluginGlob, { dot: true })
+                ? (0, devkit_internals_1.findMatchingConfigFiles)([pathToConfigFile], plugin.include, plugin.exclude)
+                : [];
             if (matchingConfigFile.length) {
                 return plugin;
             }

package/dist/src/utils/get-named-inputs.d.ts

@@ -1,8 +1,8 @@
 import type { InputDefinition } from 'nx/src/config/workspace-json-project-json';
-import { CreateNodesContextV2 } from 'nx/src/devkit-exports';
+import { CreateNodesContext } from 'nx/src/devkit-exports';
 /**
  * Get the named inputs available for a directory
  */
-export declare function getNamedInputs(directory: string, context: CreateNodesContextV2): {
+export declare function getNamedInputs(directory: string, context: CreateNodesContext): {
     [inputName: string]: (string | InputDefinition)[];
 };

package/dist/src/utils/package-json.js

@@ -456,7 +456,7 @@ function ensurePackage(pkgOrTree, requiredVersionOrPackage, maybeRequiredVersion
     if (process.env.NX_DRY_RUN && process.env.NX_DRY_RUN !== 'false') {
         throw new Error('NOTE: This generator does not support --dry-run. If you are running this in Nx Console, it should execute fine once you hit the "Generate" button.\n');
     }
-    const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion);
+    const { tempDir } = (0, devkit_internals_1.installPackageToTmp)(pkg, requiredVersion, (0, devkit_exports_1.detectPackageManager)(devkit_exports_1.workspaceRoot));
     addToNodePath((0, path_1.join)(devkit_exports_1.workspaceRoot, 'node_modules'));
     addToNodePath((0, path_1.join)(tempDir, 'node_modules'));
     // Re-initialize the added paths into require

package/dist/src/utils/replace-project-configuration-with-plugin.d.ts

@@ -1,2 +1,2 @@
-import { CreateNodesV2, Tree } from 'nx/src/devkit-exports';
-export declare function replaceProjectConfigurationsWithPlugin<T = unknown>(tree: Tree, rootMappings: Map<string, string>, pluginPath: string, createNodes: CreateNodesV2<T>, pluginOptions: T): Promise<void>;
+import { CreateNodes, Tree } from 'nx/src/devkit-exports';
+export declare function replaceProjectConfigurationsWithPlugin<T = unknown>(tree: Tree, rootMappings: Map<string, string>, pluginPath: string, createNodes: CreateNodes<T>, pluginOptions: T): Promise<void>;

package/migrations.json

@@ -5,6 +5,12 @@
       "description": "Rewrite imports from `@nx/devkit/src/...` to `@nx/devkit` (for public symbols) or `@nx/devkit/internal` (for the rest), since deep imports are no longer reachable through the package's `exports` map.",
       "implementation": "./dist/src/migrations/update-23-0-0/update-deep-imports",
       "documentation": "./dist/src/migrations/update-23-0-0/update-deep-imports.md"
+    },
+    "update-23-0-0-rename-create-nodes-v2-types": {
+      "version": "23.0.0-beta.24",
+      "description": "Rename deprecated CreateNodes `V2` type imports (CreateNodesV2, CreateNodesContextV2, CreateNodesResultV2, CreateNodesFunctionV2, NxPluginV2) from `@nx/devkit` to their canonical names.",
+      "implementation": "./dist/src/migrations/update-23-0-0/rename-create-nodes-v2-types",
+      "documentation": "./dist/src/migrations/update-23-0-0/rename-create-nodes-v2-types.md"
     }
   },
   "packageJsonUpdates": {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "23.0.0-beta.22",
+  "version": "23.0.0-beta.24",
   "private": false,
   "type": "commonjs",
   "files": [
@@ -60,7 +60,7 @@
   },
   "devDependencies": {
     "jest": "30.3.0",
-    "nx": "23.0.0-beta.22"
+    "nx": "23.0.0-beta.24"
   },
   "peerDependencies": {
     "nx": ">= 22 <= 24 || ^23.0.0-0"