nx 18.1.0-canary.20240223-21e7648 → 18.1.0-canary.20240224-26b266f

package/src/{utils/nx-plugin.d.ts → project-graph/plugins/public-api.d.ts}

@@ -1,9 +1,8 @@
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
-import { PackageJson } from './package-json';
-import { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { NxJsonConfiguration, PluginConfiguration } from '../config/nx-json';
-import { NxPluginV1 } from './nx-plugin.deprecated';
-import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { RawProjectGraphDependency } from '../project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
@@ -16,6 +15,7 @@ export interface CreateNodesContext {
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
      * A map of project root -> project configuration
@@ -79,41 +79,7 @@ export type NxPluginV2<TOptions = unknown> = {
      */
     createDependencies?: CreateDependencies<TOptions>;
 };
-export * from './nx-plugin.deprecated';
 /**
  * A plugin for Nx
  */
 export type NxPlugin = NxPluginV1 | NxPluginV2;
-export type LoadedNxPlugin = {
-    plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
-    options?: unknown;
-};
-export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
-export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
-    pluginPath: string;
-    name: any;
-};
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
-export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string, projects?: Record<string, ProjectConfiguration>): Promise<LoadedNxPlugin[]>;
-export declare function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2;
-export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
-export declare function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1;
-export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
-    path: string;
-    json: PackageJson;
-};
-export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
-    path: string;
-    projectConfig: ProjectConfiguration;
-} | null;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-export declare function registerPluginTSTranspiler(): void;
-/**
- * Unregister the ts-node transpiler if it is registered
- */
-export declare function unregisterPluginTSTranspiler(): void;
-export declare function getDefaultPlugins(root: string): Promise<LoadedNxPlugin[]>;
-type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/project-graph/plugins/public-api.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file represents the public API for plugins which live in nx.json's plugins array.
+// For methods to interact with plugins from within Nx, see `./internal-api.ts`.
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/project-graph/plugins/worker-api.d.ts

@@ -0,0 +1,26 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { PluginConfiguration } from '../../config/nx-json';
+import { PackageJson } from '../../utils/package-json';
+import { NxPlugin } from './public-api';
+export type LoadedNxPlugin = {
+    plugin: NxPlugin;
+    options?: unknown;
+};
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+};

package/src/project-graph/plugins/worker-api.js

@@ -0,0 +1,177 @@
+"use strict";
+// This file contains methods and utilities that should **only** be used by the plugin worker.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPluginPathAndName = exports.registerPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = exports.loadNxPluginAsync = void 0;
+const posix_1 = require("node:path/posix");
+const installation_directory_1 = require("../../utils/installation-directory");
+const package_json_1 = require("../../utils/package-json");
+const fileutils_1 = require("../../utils/fileutils");
+const path = require("node:path/posix");
+const workspace_root_1 = require("../../utils/workspace-root");
+const node_fs_1 = require("node:fs");
+const typescript_1 = require("../../utils/typescript");
+const register_1 = require("../../plugins/js/utils/register");
+const find_project_for_path_1 = require("../utils/find-project-for-path");
+const path_1 = require("../../utils/path");
+const logger_1 = require("../../utils/logger");
+const node_path_1 = require("node:path");
+const internal_api_1 = require("./internal-api");
+async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
+    const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
+        ? pluginConfiguration
+        : { plugin: pluginConfiguration, options: undefined };
+    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
+    const plugin = (0, internal_api_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
+    plugin.name ??= name;
+    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+    return { plugin, options };
+}
+exports.loadNxPluginAsync = loadNxPluginAsync;
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+    try {
+        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
+        return {
+            json: result.packageJson,
+            path: result.path,
+        };
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
+            if (localPluginPath) {
+                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                return {
+                    path: localPluginPackageJson,
+                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
+                };
+            }
+        }
+        throw e;
+    }
+}
+exports.readPluginPackageJson = readPluginPackageJson;
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
+exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    // Get the first tsconfig that matches the allowed set
+    const tsConfigName = [
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+    ].find((x) => (0, node_fs_1.existsSync)(x));
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfig)(tsConfigName)
+        : {};
+    (0, register_1.registerTsConfigPaths)(tsConfigName);
+    (0, register_1.registerTranspiler)({
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        ...tsConfig.options,
+    });
+}
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const plugin = findNxProjectForImportPath(importPath, projects, root);
+    if (!plugin) {
+        return null;
+    }
+    const projectConfig = projects[plugin];
+    return { path: path.join(root, projectConfig.root), projectConfig };
+}
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
+    if (possiblePaths?.length) {
+        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+        for (const tsConfigPath of possiblePaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return nxProject;
+            }
+        }
+        logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
+        throw new Error('Unable to resolve local plugin with import path ' + importPath);
+    }
+}
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
+        }
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
+    }
+    return tsconfigPaths ?? {};
+}
+function readPluginMainFromProjectConfiguration(plugin) {
+    const { main } = Object.values(plugin.targets).find((x) => [
+        '@nx/js:tsc',
+        '@nrwl/js:tsc',
+        '@nx/js:swc',
+        '@nrwl/js:swc',
+        '@nx/node:package',
+        '@nrwl/node:package',
+    ].includes(x.executor))?.options ||
+        plugin.targets?.build?.options ||
+        {};
+    return main;
+}
+function getPluginPathAndName(moduleName, paths, projects, root) {
+    let pluginPath;
+    let registerTSTranspiler = false;
+    try {
+        pluginPath = require.resolve(moduleName, {
+            paths,
+        });
+        const extension = path.extname(pluginPath);
+        registerTSTranspiler = extension === '.ts';
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
+            if (plugin) {
+                registerTSTranspiler = true;
+                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+                pluginPath = main ? path.join(root, main) : plugin.path;
+            }
+            else {
+                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+                throw e;
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    // Register the ts-transpiler if we are pointing to a
+    // plain ts file that's not part of a plugin project
+    if (registerTSTranspiler) {
+        registerPluginTSTranspiler();
+    }
+    const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.extname)(moduleName) === x) && // Not trying to point to a ts or js file
+        (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
+        : { name: moduleName };
+    return { pluginPath, name };
+}
+exports.getPluginPathAndName = getPluginPathAndName;
+async function importPluginModule(pluginPath) {
+    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
+    if (m.default &&
+        ('createNodes' in m.default || 'createDependencies' in m.default)) {
+        return m.default;
+    }
+    return m;
+}

package/src/project-graph/project-graph-builder.d.ts

@@ -2,7 +2,7 @@
  * Builder for adding nodes and dependencies to a {@link ProjectGraph}
  */
 import { DependencyType, FileMap, ProjectFileMap, ProjectGraph, ProjectGraphExternalNode, ProjectGraphProjectNode } from '../config/project-graph';
-import { CreateDependenciesContext } from '../utils/nx-plugin';
+import { CreateDependenciesContext } from './plugins';
 /**
  * A class which builds up a project graph
  * @deprecated The {@link ProjectGraphProcessor} has been deprecated. Use a {@link CreateNodes} and/or a {@link CreateDependencies} instead. This will be removed in Nx 19.

package/src/project-graph/project-graph.js

@@ -12,7 +12,6 @@ const workspace_root_1 = require("../utils/workspace-root");
 const perf_hooks_1 = require("perf_hooks");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const nx_json_1 = require("../config/nx-json");
-const nx_plugin_1 = require("../utils/nx-plugin");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
  * @throws {Error} if there is no cached ProjectGraph to read from
@@ -77,7 +76,6 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
     const projectGraph = (await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, cacheEnabled)).projectGraph;
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:end');
-    (0, nx_plugin_1.unregisterPluginTSTranspiler)();
     return { projectGraph, sourceMaps };
 }
 exports.buildProjectGraphAndSourceMapsWithoutDaemon = buildProjectGraphAndSourceMapsWithoutDaemon;

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -1,7 +1,7 @@
 import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
-import { CreateDependenciesContext } from '../../utils/nx-plugin';
+import { CreateDependenciesContext } from '../plugins';
 export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
 /**
  * Apply target defaults and normalization

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -1,8 +1,8 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
-import { LoadedNxPlugin } from '../../utils/nx-plugin';
 import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/target-defaults-plugin';
+import { RemotePlugin } from '../plugins/internal-api';
 export type SourceInformation = [file: string, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
 export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
@@ -25,7 +25,7 @@ export type ConfigurationResult = {
  * @param root The workspace root
  */
 export declare function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
-plugins: LoadedNxPlugin[], root?: string): Promise<ConfigurationResult>;
+plugins: RemotePlugin[], root?: string): Promise<ConfigurationResult>;
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 /**
  * Merges two targets.

package/src/project-graph/utils/project-configuration-utils.js

@@ -108,13 +108,13 @@ skipCommandNormalization) {
                 !matchingProject.targets?.[targetName]) {
                 continue;
             }
+            const mergedTarget = mergeTargetConfigurations(skipCommandNormalization
+                ? target
+                : resolveCommandSyntacticSugar(target, project.root), matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
             // We don't want the symbol to live on past the merge process
-            if (target?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET])
-                delete target?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET];
-            updatedProjectConfiguration.targets[targetName] =
-                mergeTargetConfigurations(skipCommandNormalization
-                    ? target
-                    : resolveCommandSyntacticSugar(target, project.root), matchingProject.targets?.[targetName], sourceMap, sourceInformation, `targets.${targetName}`);
+            if (mergedTarget?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET])
+                delete mergedTarget?.[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET];
+            updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
     projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
@@ -132,57 +132,30 @@ function buildProjectsConfigurationsFromProjectPathsAndPlugins(nxJson, projectFi
 plugins, root = workspace_root_1.workspaceRoot) {
     const results = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const { plugin, options } of plugins) {
+    for (const plugin of plugins) {
         const [pattern, createNodes] = plugin.createNodes ?? [];
-        const pluginResults = [];
-        performance.mark(`${plugin.name}:createNodes - start`);
         if (!pattern) {
             continue;
         }
+        const matchedFiles = [];
+        performance.mark(`${plugin.name}:createNodes - start`);
         // Set this globally to allow plugins to know if they are being called from the project graph creation
         global.NX_GRAPH_CREATION = true;
         for (const file of projectFiles) {
-            performance.mark(`${plugin.name}:createNodes:${file} - start`);
             if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                try {
-                    let r = createNodes(file, options, {
-                        nxJsonConfiguration: nxJson,
-                        workspaceRoot: root,
-                    });
-                    if (r instanceof Promise) {
-                        pluginResults.push(r
-                            .catch((e) => {
-                            performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                            throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
-                        })
-                            .then((r) => {
-                            performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                            performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-                            return { ...r, file, pluginName: plugin.name };
-                        }));
-                    }
-                    else {
-                        performance.mark(`${plugin.name}:createNodes:${file} - end`);
-                        performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-                        pluginResults.push({
-                            ...r,
-                            file,
-                            pluginName: plugin.name,
-                        });
-                    }
-                }
-                catch (e) {
-                    throw new CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
-                }
+                matchedFiles.push(file);
             }
         }
-        // If there are no promises (counter undefined) or all promises have resolved (counter === 0)
-        results.push(Promise.all(pluginResults).then((results) => {
-            delete global.NX_GRAPH_CREATION;
-            performance.mark(`${plugin.name}:createNodes - end`);
-            performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
-            return results;
-        }));
+        try {
+            let r = createNodes(matchedFiles, {
+                nxJsonConfiguration: nxJson,
+                workspaceRoot: root,
+            });
+            results.push(r);
+        }
+        catch (e) {
+            throw new CreateNodesError(`Unable to create nodes using plugin ${plugin.name}.`, e);
+        }
     }
     return Promise.all(results).then((results) => {
         performance.mark('createNodes:merge - start');
@@ -288,6 +261,13 @@ function mergeTargetConfigurations(target, baseTarget, projectConfigSourceMap, s
     // Target is "compatible", e.g. executor is defined only once or is the same
     // in both places. This means that it is likely safe to merge
     const isCompatible = isCompatibleTarget(baseTargetProperties, target);
+    // If the targets are not compatible, we would normally overwrite the old target
+    // with the new one. However, we have a special case for targets that have the
+    // ONLY_MODIFIES_EXISTING_TARGET symbol set. This prevents the merged target
+    // equaling info that should have only been used to modify the existing target.
+    if (!isCompatible && target[target_defaults_plugin_1.ONLY_MODIFIES_EXISTING_TARGET]) {
+        return baseTarget;
+    }
     if (!isCompatible && projectConfigSourceMap) {
         // if the target is not compatible, we will simply override the options
         // we have to delete old entries from the source map

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -2,7 +2,7 @@ import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ConfigurationSourceMaps } from './project-configuration-utils';
-import { LoadedNxPlugin } from '../../utils/nx-plugin';
+import { RemotePlugin } from '../plugins/internal-api';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -31,7 +31,11 @@ export type RetrievedGraphNodes = {
     sourceMaps: ConfigurationSourceMaps;
     projectRootMap: Record<string, string>;
 };
-export declare function retrieveProjectConfigurationPaths(root: string, plugins: LoadedNxPlugin[]): string[];
+export declare function retrieveProjectConfigurationPaths(root: string, plugins: PluginGlobsOnly): string[];
 export declare function retrieveProjectConfigurationsWithoutPluginInference(root: string): Promise<Record<string, ProjectConfiguration>>;
-export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: LoadedNxPlugin[]): Promise<RetrievedGraphNodes>;
-export declare function configurationGlobs(plugins: LoadedNxPlugin[]): string[];
+export declare function createProjectConfigurations(workspaceRoot: string, nxJson: NxJsonConfiguration, configFiles: string[], plugins: RemotePlugin[]): Promise<RetrievedGraphNodes>;
+type PluginGlobsOnly = Array<{
+    createNodes?: readonly [string, ...unknown[]];
+}>;
+export declare function configurationGlobs(plugins: PluginGlobsOnly): string[];
+export {};

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -2,15 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configurationGlobs = exports.createProjectConfigurations = exports.retrieveProjectConfigurationsWithoutPluginInference = exports.retrieveProjectConfigurationPaths = exports.retrieveProjectConfigurationsWithAngularProjects = exports.retrieveProjectConfigurations = exports.retrieveWorkspaceFiles = void 0;
 const perf_hooks_1 = require("perf_hooks");
-const installation_directory_1 = require("../../utils/installation-directory");
 const angular_json_1 = require("../../adapter/angular-json");
 const nx_json_1 = require("../../config/nx-json");
-const package_json_workspaces_1 = require("../../plugins/package-json-workspaces");
 const project_configuration_utils_1 = require("./project-configuration-utils");
-const nx_plugin_1 = require("../../utils/nx-plugin");
-const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
+const internal_api_1 = require("../plugins/internal-api");
 const workspace_context_1 = require("../../utils/workspace-context");
 const build_all_workspace_files_1 = require("./build-all-workspace-files");
+const path_1 = require("path");
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws
@@ -42,16 +40,18 @@ exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
  * @param nxJson
  */
 async function retrieveProjectConfigurations(workspaceRoot, nxJson) {
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
+    const plugins = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
     return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
 }
 exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
 async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, nxJson) {
-    const plugins = await (0, nx_plugin_1.loadNxPlugins)(nxJson?.plugins ?? [], (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), workspaceRoot);
+    const pluginsToLoad = nxJson?.plugins ?? [];
     if ((0, angular_json_1.shouldMergeAngularProjects)(workspaceRoot, true) &&
-        !plugins.some((p) => p.plugin.name === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME)) {
-        plugins.push({ plugin: angular_json_1.NxAngularJsonPlugin });
+        !pluginsToLoad.some((p) => p === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME ||
+            (typeof p === 'object' && p.plugin === angular_json_1.NX_ANGULAR_JSON_PLUGIN_NAME))) {
+        pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
     }
+    const plugins = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
     return _retrieveProjectConfigurations(workspaceRoot, nxJson, plugins);
 }
 exports.retrieveProjectConfigurationsWithAngularProjects = retrieveProjectConfigurationsWithAngularProjects;
@@ -69,17 +69,14 @@ const projectsWithoutPluginCache = new Map();
 // TODO: This function is called way too often, it should be optimized without this cache
 async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
-    const plugins = await (0, nx_plugin_1.getDefaultPlugins)(root);
+    const plugins = await (0, internal_api_1.loadNxPlugins)([]); // only load default plugins
     const projectGlobPatterns = retrieveProjectConfigurationPaths(root, plugins);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
     const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns);
-    const { projects } = await createProjectConfigurations(root, nxJson, projectFiles, [
-        { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root) },
-        { plugin: project_json_1.ProjectJsonProjectsPlugin },
-    ]);
+    const { projects } = await createProjectConfigurations(root, nxJson, projectFiles, plugins);
     projectsWithoutPluginCache.set(cacheKey, projects);
     return projects;
 }
@@ -99,7 +96,7 @@ async function createProjectConfigurations(workspaceRoot, nxJson, configFiles, p
 exports.createProjectConfigurations = createProjectConfigurations;
 function configurationGlobs(plugins) {
     const globPatterns = [];
-    for (const { plugin } of plugins) {
+    for (const plugin of plugins) {
         if (plugin.createNodes) {
             globPatterns.push(plugin.createNodes[0]);
         }

package/src/utils/logger.d.ts

@@ -7,5 +7,6 @@ export declare const logger: {
     log: (...s: any[]) => void;
     debug: (...s: any[]) => void;
     fatal: (...s: any[]) => void;
+    verbose: (...s: any[]) => void;
 };
 export declare function stripIndent(str: string): string;

package/src/utils/logger.js

@@ -34,6 +34,11 @@ exports.logger = {
     fatal: (...s) => {
         console.error(...s);
     },
+    verbose: (...s) => {
+        if (process.env.NX_VERBOSE_LOGGING) {
+            console.log(...s);
+        }
+    },
 };
 function stripIndent(str) {
     const match = str.match(/^[ \t]*(?=\S)/gm);

package/src/utils/nx-plugin.deprecated.d.ts

@@ -1,6 +1,6 @@
 import { ProjectGraphProcessor } from '../config/project-graph';
 import { TargetConfiguration } from '../config/workspace-json-project-json';
-import { LoadedNxPlugin } from './nx-plugin';
+import { NxPluginV2 } from '../project-graph/plugins';
 /**
  * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 19
  */
@@ -28,4 +28,6 @@ export type NxPluginV1 = {
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
-export declare function getDefaultPluginsSync(root: string): LoadedNxPlugin[];
+export declare function getDefaultPluginsSync(root: string): {
+    plugin: NxPluginV2;
+}[];

package/src/utils/nx-plugin.deprecated.js

@@ -4,7 +4,7 @@ exports.getDefaultPluginsSync = void 0;
 const angular_json_1 = require("../adapter/angular-json");
 const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
 const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
-const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
+const PackageJsonWorkspacesPlugin = require("../plugins/package-json-workspaces");
 /**
  * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
  */
@@ -14,9 +14,9 @@ function getDefaultPluginsSync(root) {
         ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
             ? [require('../adapter/angular-json').NxAngularJsonPlugin]
             : []),
-        target_defaults_plugin_1.TargetDefaultsPlugin,
-        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
-        project_json_1.ProjectJsonProjectsPlugin,
+        target_defaults_plugin_1.default,
+        PackageJsonWorkspacesPlugin,
+        project_json_1.default,
     ];
     return plugins.map((p) => ({
         plugin: p,

package/src/utils/package-json.js

@@ -48,7 +48,7 @@ function buildTargetFromScript(script) {
 }
 exports.buildTargetFromScript = buildTargetFromScript;
 function readTargetsFromPackageJson(packageJson) {
-    const { scripts, nx } = packageJson;
+    const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
     //
@@ -63,7 +63,7 @@ function readTargetsFromPackageJson(packageJson) {
      * not marked as `"private": true` to allow for lightweight configuration for
      * package based repos.
      */
-    if (!packageJson.private && !res['nx-release-publish']) {
+    if (!isPrivate && !res['nx-release-publish']) {
         res['nx-release-publish'] = {
             dependsOn: ['^nx-release-publish'],
             executor: '@nx/js:release-publish',

package/src/utils/plugins/plugin-capabilities.d.ts

@@ -1,4 +1,4 @@
-import type { PluginCapabilities } from './models';
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { PluginCapabilities } from './models';
 export declare function getPluginCapabilities(workspaceRoot: string, pluginName: string, projects: Record<string, ProjectConfiguration>, includeRuntimeCapabilities?: boolean): Promise<PluginCapabilities | null>;
 export declare function listPluginCapabilities(pluginName: string, projects: Record<string, ProjectConfiguration>): Promise<void>;