nx 20.3.0-canary.20241213-0d6667d → 20.3.0-canary.20241217-ee4de0b

package/src/config/schema-utils.d.ts

@@ -1,15 +1,16 @@
+import type { ProjectConfiguration } from './workspace-json-project-json';
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation
  * @param directory path to the directory
  * @returns a function that returns the implementation
  */
-export declare function getImplementationFactory<T>(implementation: string, directory: string): () => T;
+export declare function getImplementationFactory<T>(implementation: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): () => T;
 /**
  * This function is used to resolve the implementation of an executor or generator.
  * @param implementationModulePath
  * @param directory
  * @returns path to the implementation
  */
-export declare function resolveImplementation(implementationModulePath: string, directory: string): string;
-export declare function resolveSchema(schemaPath: string, directory: string): string;
+export declare function resolveImplementation(implementationModulePath: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): string;
+export declare function resolveSchema(schemaPath: string, directory: string, packageName: string, projects: Record<string, ProjectConfiguration>): string;

package/src/config/schema-utils.js

@@ -5,17 +5,20 @@ exports.resolveImplementation = resolveImplementation;
 exports.resolveSchema = resolveSchema;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const resolve_exports_1 = require("resolve.exports");
+const packages_1 = require("../plugins/js/utils/packages");
 const plugins_1 = require("../project-graph/plugins");
+const path_2 = require("../utils/path");
 /**
  * This function is used to get the implementation factory of an executor or generator.
  * @param implementation path to the implementation
  * @param directory path to the directory
  * @returns a function that returns the implementation
  */
-function getImplementationFactory(implementation, directory) {
+function getImplementationFactory(implementation, directory, packageName, projects) {
     const [implementationModulePath, implementationExportName] = implementation.split('#');
     return () => {
-        const modulePath = resolveImplementation(implementationModulePath, directory);
+        const modulePath = resolveImplementation(implementationModulePath, directory, packageName, projects);
         if ((0, path_1.extname)(modulePath) === '.ts') {
             (0, plugins_1.registerPluginTSTranspiler)();
         }
@@ -31,8 +34,19 @@ function getImplementationFactory(implementation, directory) {
  * @param directory
  * @returns path to the implementation
  */
-function resolveImplementation(implementationModulePath, directory) {
+function resolveImplementation(implementationModulePath, directory, packageName, projects) {
     const validImplementations = ['', '.js', '.ts'].map((x) => implementationModulePath + x);
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the implementation path points to the
+        // outputs which might not exist or can be stale. We prioritize finding
+        // the implementation from the source over the outputs.
+        for (const maybeImplementation of validImplementations) {
+            const maybeImplementationFromSource = tryResolveFromSource(maybeImplementation, directory, packageName, projects);
+            if (maybeImplementationFromSource) {
+                return maybeImplementationFromSource;
+            }
+        }
+    }
     for (const maybeImplementation of validImplementations) {
         const maybeImplementationPath = (0, path_1.join)(directory, maybeImplementation);
         if ((0, fs_1.existsSync)(maybeImplementationPath)) {
@@ -47,7 +61,16 @@ function resolveImplementation(implementationModulePath, directory) {
     }
     throw new Error(`Could not resolve "${implementationModulePath}" from "${directory}".`);
 }
-function resolveSchema(schemaPath, directory) {
+function resolveSchema(schemaPath, directory, packageName, projects) {
+    if (!directory.includes('node_modules')) {
+        // It might be a local plugin where the schema path points to the outputs
+        // which might not exist or can be stale. We prioritize finding the schema
+        // from the source over the outputs.
+        const schemaPathFromSource = tryResolveFromSource(schemaPath, directory, packageName, projects);
+        if (schemaPathFromSource) {
+            return schemaPathFromSource;
+        }
+    }
     const maybeSchemaPath = (0, path_1.join)(directory, schemaPath);
     if ((0, fs_1.existsSync)(maybeSchemaPath)) {
         return maybeSchemaPath;
@@ -56,3 +79,47 @@ function resolveSchema(schemaPath, directory) {
         paths: [directory],
     });
 }
+let packageEntryPointsToProjectMap;
+function tryResolveFromSource(path, directory, packageName, projects) {
+    packageEntryPointsToProjectMap ??=
+        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    const localProject = packageEntryPointsToProjectMap[packageName];
+    if (!localProject) {
+        // it doesn't match any of the package names from the local projects
+        return null;
+    }
+    try {
+        const fromExports = (0, resolve_exports_1.resolve)({
+            name: localProject.metadata.js.packageName,
+            exports: localProject.metadata.js.packageExports,
+        }, path, { conditions: ['development'] });
+        if (fromExports && fromExports.length) {
+            for (const exportPath of fromExports) {
+                if ((0, fs_1.existsSync)((0, path_1.join)(directory, exportPath))) {
+                    return (0, path_1.join)(directory, exportPath);
+                }
+            }
+        }
+    }
+    catch { }
+    /**
+     * Fall back to try to "guess" the source by checking the path in some common directories:
+     * - the root of the project
+     * - the src directory
+     * - the src/lib directory
+     */
+    const segments = (0, path_2.normalizePath)(path).replace(/^\.\//, '').split('/');
+    for (let i = 1; i < segments.length; i++) {
+        const possiblePaths = [
+            (0, path_1.join)(directory, ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', ...segments.slice(i)),
+            (0, path_1.join)(directory, 'src', 'lib', ...segments.slice(i)),
+        ];
+        for (const possiblePath of possiblePaths) {
+            if ((0, fs_1.existsSync)(possiblePath)) {
+                return possiblePath;
+            }
+        }
+    }
+    return null;
+}

package/src/config/workspace-json-project-json.d.ts

@@ -1,3 +1,4 @@
+import type { PackageJson } from '../utils/package-json';
 import type { NxJsonConfiguration, NxReleaseVersionConfiguration } from './nx-json';
 /**
  * @deprecated use ProjectsConfigurations or NxJsonConfiguration
@@ -122,6 +123,10 @@ export interface ProjectMetadata {
             }[];
         };
     };
+    js?: {
+        packageName: string;
+        packageExports: undefined | PackageJson['exports'];
+    };
 }
 export interface TargetMetadata {
     [k: string]: any;

package/src/daemon/client/client.js

@@ -30,6 +30,7 @@ const get_sync_generator_changes_1 = require("../message-types/get-sync-generato
 const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
 const update_workspace_context_1 = require("../message-types/update-workspace-context");
 const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
+const delayed_spinner_1 = require("../../utils/delayed-spinner");
 const DAEMON_ENV_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -113,6 +114,11 @@ class DaemonClient {
         return this.sendToDaemonViaQueue({ type: 'REQUEST_SHUTDOWN' });
     }
     async getProjectGraphAndSourceMaps() {
+        let spinner;
+        if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+            // If the graph takes a while to load, we want to show a spinner.
+            spinner = new delayed_spinner_1.DelayedSpinner('Calculating the project graph on the Nx Daemon', 500).scheduleMessageUpdate('Calculating the project graph on the Nx Daemon is taking longer than expected. Re-run with NX_DAEMON=false to see more details.', 30_000);
+        }
         try {
             const response = await this.sendToDaemonViaQueue({
                 type: 'REQUEST_PROJECT_GRAPH',
@@ -130,6 +136,9 @@ class DaemonClient {
                 throw e;
             }
         }
+        finally {
+            spinner?.cleanup();
+        }
     }
     async getAllFileData() {
         return await this.sendToDaemonViaQueue({ type: 'REQUEST_FILE_DATA' });

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.d.ts

@@ -1,4 +1,4 @@
-import { CreateDependenciesContext } from '../../../../project-graph/plugins';
-import { RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
+import type { CreateDependenciesContext } from '../../../../project-graph/plugins';
+import { type RawProjectGraphDependency } from '../../../../project-graph/project-graph-builder';
 import { TargetProjectLocator } from './target-project-locator';
 export declare function buildExplicitPackageJsonDependencies(ctx: CreateDependenciesContext, targetProjectLocator: TargetProjectLocator): RawProjectGraphDependency[];

package/src/plugins/js/project-graph/build-dependencies/explicit-package-json-dependencies.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildExplicitPackageJsonDependencies = buildExplicitPackageJsonDependencies;
-const node_path_1 = require("node:path");
 const project_graph_1 = require("../../../../config/project-graph");
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const project_graph_builder_1 = require("../../../../project-graph/project-graph-builder");
@@ -9,43 +8,30 @@ const json_1 = require("../../../../utils/json");
 const path_1 = require("../../../../utils/path");
 function buildExplicitPackageJsonDependencies(ctx, targetProjectLocator) {
     const res = [];
-    let packageNameMap = undefined;
     const nodes = Object.values(ctx.projects);
     Object.keys(ctx.filesToProcess.projectFileMap).forEach((source) => {
         Object.values(ctx.filesToProcess.projectFileMap[source]).forEach((f) => {
             if (isPackageJsonAtProjectRoot(nodes, f.file)) {
-                // we only create the package name map once and only if a package.json file changes
-                packageNameMap = packageNameMap || createPackageNameMap(ctx.projects);
-                processPackageJson(source, f.file, ctx, targetProjectLocator, res, packageNameMap);
+                processPackageJson(source, f.file, ctx, targetProjectLocator, res);
             }
         });
     });
     return res;
 }
-function createPackageNameMap(projects) {
-    const res = {};
-    for (let projectName of Object.keys(projects)) {
-        try {
-            const packageJson = (0, json_1.parseJson)((0, file_utils_1.defaultFileRead)((0, node_path_1.join)(projects[projectName].root, 'package.json')));
-            res[packageJson.name ?? projectName] = projectName;
-        }
-        catch (e) { }
-    }
-    return res;
-}
 function isPackageJsonAtProjectRoot(nodes, fileName) {
     return (fileName.endsWith('package.json') &&
         nodes.find((projectNode) => (0, path_1.joinPathFragments)(projectNode.root, 'package.json') === fileName));
 }
-function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps, packageNameMap) {
+function processPackageJson(sourceProject, fileName, ctx, targetProjectLocator, collectedDeps) {
     try {
         const deps = readDeps((0, json_1.parseJson)((0, file_utils_1.defaultFileRead)(fileName)));
         for (const d of Object.keys(deps)) {
-            // package.json refers to another project in the monorepo
-            if (packageNameMap[d]) {
+            const localProject = targetProjectLocator.findDependencyInWorkspaceProjects(d);
+            if (localProject) {
+                // package.json refers to another project in the monorepo
                 const dependency = {
                     source: sourceProject,
-                    target: packageNameMap[d],
+                    target: localProject,
                     sourceFile: fileName,
                     type: project_graph_1.DependencyType.static,
                 };

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.d.ts

@@ -1,4 +1,4 @@
-import { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
+import type { ProjectGraphExternalNode, ProjectGraphProjectNode } from '../../../../config/project-graph';
 /**
  * The key is a combination of the package name and the workspace relative directory
  * containing the file importing it e.g. `lodash__packages/my-lib`, the value is the
@@ -15,6 +15,7 @@ export declare class TargetProjectLocator {
     private tsConfig;
     private paths;
     private typescriptResolutionCache;
+    private packageEntryPointsToProjectMap;
     constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes?: Record<string, ProjectGraphExternalNode>, npmResolutionCache?: NpmResolutionCache);
     /**
      * Resolve any workspace or external project that matches the given import expression,
@@ -38,6 +39,7 @@ export declare class TargetProjectLocator {
      * @returns
      */
     findPaths(normalizedImportExpr: string): string[] | undefined;
+    findDependencyInWorkspaceProjects(dep: string): string | null;
     private resolveImportWithTypescript;
     private resolveImportWithRequire;
     private findProjectOfResolvedModule;

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -7,10 +7,11 @@ const node_path_1 = require("node:path");
 const semver_1 = require("semver");
 const find_project_for_path_1 = require("../../../../project-graph/utils/find-project-for-path");
 const fileutils_1 = require("../../../../utils/fileutils");
+const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
 const workspace_root_1 = require("../../../../utils/workspace-root");
+const packages_1 = require("../../utils/packages");
 const resolve_relative_to_dir_1 = require("../../utils/resolve-relative-to-dir");
 const typescript_1 = require("../../utils/typescript");
-const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
 /**
  * Use a shared cache to avoid repeated npm package resolution work within the TargetProjectLocator.
  */
@@ -98,6 +99,12 @@ class TargetProjectLocator {
             return this.findProjectOfResolvedModule(resolvedModule);
         }
         catch { }
+        // fall back to see if it's a locally linked workspace project where the
+        // output might not exist yet
+        const localProject = this.findDependencyInWorkspaceProjects(importExpr);
+        if (localProject) {
+            return localProject;
+        }
         // nothing found, cache for later
         this.npmResolutionCache.set(importExpr, null);
         return null;
@@ -182,6 +189,10 @@ class TargetProjectLocator {
         }
         return undefined;
     }
+    findDependencyInWorkspaceProjects(dep) {
+        this.packageEntryPointsToProjectMap ??= (0, packages_1.getPackageEntryPointsToProjectMap)(this.nodes);
+        return this.packageEntryPointsToProjectMap[dep]?.name ?? null;
+    }
     resolveImportWithTypescript(normalizedImportExpr, filePath) {
         let resolvedModule;
         if (this.typescriptResolutionCache.has(normalizedImportExpr)) {

package/src/plugins/js/utils/packages.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectGraphProjectNode } from '../../../config/project-graph';
+import type { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+export declare function getPackageEntryPointsToProjectMap<T extends ProjectGraphProjectNode | ProjectConfiguration>(projects: Record<string, T>): Record<string, T>;

package/src/plugins/js/utils/packages.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageEntryPointsToProjectMap = getPackageEntryPointsToProjectMap;
+const posix_1 = require("node:path/posix");
+function getPackageEntryPointsToProjectMap(projects) {
+    const result = {};
+    for (const project of Object.values(projects)) {
+        const metadata = 'data' in project ? project.data.metadata : project.metadata;
+        if (!metadata?.js) {
+            continue;
+        }
+        const { packageName, packageExports } = metadata.js;
+        if (!packageExports || typeof packageExports === 'string') {
+            // no `exports` or it points to a file, which would be the equivalent of
+            // an '.' export, in which case the package name is the entry point
+            result[packageName] = project;
+        }
+        else {
+            for (const entryPoint of Object.keys(packageExports)) {
+                result[(0, posix_1.join)(packageName, entryPoint)] = project;
+            }
+        }
+    }
+    return result;
+}

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

@@ -84,6 +84,12 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache) {
     const hash = (0, file_hasher_1.hashObject)({
         ...json,
         root: projectRoot,
+        /**
+         * Increment this number to force processing the package.json again. Do it
+         * when the implementation of this plugin is changed and results in different
+         * results for the same package.json contents.
+         */
+        bust: 1,
     });
     const cached = cache[hash];
     if (cached) {

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

@@ -18,6 +18,7 @@ const configuration_1 = require("../config/configuration");
 const fs_1 = require("fs");
 const error_types_1 = require("./error-types");
 const project_configuration_utils_1 = require("./utils/project-configuration-utils");
+const delayed_spinner_1 = require("../utils/delayed-spinner");
 let storedFileMap = null;
 let storedAllWorkspaceFiles = null;
 let storedRustReferences = null;
@@ -186,11 +187,39 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
     const builder = new project_graph_builder_1.ProjectGraphBuilder(graph, context.fileMap.projectFileMap, context.fileMap.nonProjectFiles);
     const createDependencyPlugins = plugins.filter((plugin) => plugin.createDependencies);
     perf_hooks_1.performance.mark('createDependencies:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            return `Creating project graph dependencies with ${inProgressPlugins.keys()[0]}`;
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            return [
+                `Creating project graph dependencies with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n');
+        }
+        else {
+            return `Creating project graph dependencies with ${inProgressPlugins.size} plugins`;
+        }
+    }
+    if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+        spinner = new delayed_spinner_1.DelayedSpinner(`Creating project graph dependencies with ${plugins.length} plugins`);
+    }
     await Promise.all(createDependencyPlugins.map(async (plugin) => {
         perf_hooks_1.performance.mark(`${plugin.name}:createDependencies - start`);
+        inProgressPlugins.add(plugin.name);
         try {
-            const dependencies = await plugin.createDependencies({
+            const dependencies = await plugin
+                .createDependencies({
                 ...context,
+            })
+                .finally(() => {
+                inProgressPlugins.delete(plugin.name);
+                updateSpinner();
             });
             for (const dep of dependencies) {
                 builder.addDependency(dep.source, dep.target, dep.type, 'sourceFile' in dep ? dep.sourceFile : null);
@@ -206,6 +235,7 @@ async function updateProjectGraphWithPlugins(context, initProjectGraph, plugins,
     }));
     perf_hooks_1.performance.mark('createDependencies:end');
     perf_hooks_1.performance.measure(`createDependencies`, `createDependencies:start`, `createDependencies:end`);
+    spinner?.cleanup();
     const graphWithDeps = builder.getUpdatedProjectGraph();
     const { errors: metadataErrors, graph: updatedGraph } = await applyProjectMetadata(graphWithDeps, plugins, {
         nxJsonConfiguration: context.nxJsonConfiguration,
@@ -232,9 +262,32 @@ async function applyProjectMetadata(graph, plugins, context, sourceMap) {
     const results = [];
     const errors = [];
     perf_hooks_1.performance.mark('createMetadata:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            return `Creating project metadata with ${inProgressPlugins.keys()[0]}`;
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            return [
+                `Creating project metadata with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n');
+        }
+        else {
+            return `Creating project metadata with ${inProgressPlugins.size} plugins`;
+        }
+    }
+    if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+        spinner = new delayed_spinner_1.DelayedSpinner(`Creating project metadata with ${plugins.length} plugins`);
+    }
     const promises = plugins.map(async (plugin) => {
         if (plugin.createMetadata) {
             perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - start`);
+            inProgressPlugins.add(plugin.name);
             try {
                 const metadata = await plugin.createMetadata(graph, context);
                 results.push({ metadata, pluginName: plugin.name });
@@ -243,12 +296,15 @@ async function applyProjectMetadata(graph, plugins, context, sourceMap) {
                 errors.push(new error_types_1.CreateMetadataError(e, plugin.name));
             }
             finally {
+                inProgressPlugins.delete(plugin.name);
+                updateSpinner();
                 perf_hooks_1.performance.mark(`${plugin.name}:createMetadata - end`);
                 perf_hooks_1.performance.measure(`${plugin.name}:createMetadata`, `${plugin.name}:createMetadata - start`, `${plugin.name}:createMetadata - end`);
             }
         }
     });
     await Promise.all(promises);
+    spinner?.cleanup();
     for (const { metadata: projectsMetadata, pluginName } of results) {
         for (const project in projectsMetadata) {
             const projectConfiguration = graph.nodes[project]?.data;

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

@@ -1,14 +1,15 @@
 import { PluginConfiguration } from '../../config/nx-json';
-import { CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2 } from './public-api';
+import { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, ProjectsMetadata } from './public-api';
 import { ProjectGraph } from '../../config/project-graph';
+import { RawProjectGraphDependency } from '../project-graph-builder';
 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]>>
     ];
-    readonly createDependencies?: (context: CreateDependenciesContext) => ReturnType<CreateDependencies>;
-    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => ReturnType<CreateMetadata>;
+    readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
+    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
     readonly options?: unknown;
     readonly include?: string[];
     readonly exclude?: string[];

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

@@ -57,10 +57,10 @@ class LoadedNxPlugin {
             };
         }
         if (plugin.createDependencies) {
-            this.createDependencies = (context) => plugin.createDependencies(this.options, context);
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
         }
         if (plugin.createMetadata) {
-            this.createMetadata = (graph, context) => plugin.createMetadata(graph, this.options, context);
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
         }
     }
 }

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

@@ -68,7 +68,7 @@ export interface PluginCreateMetadataMessage {
 export interface PluginCreateDependenciesResult {
     type: 'createDependenciesResult';
     payload: {
-        dependencies: ReturnType<LoadedNxPlugin['createDependencies']>;
+        dependencies: Awaited<ReturnType<LoadedNxPlugin['createDependencies']>>;
         success: true;
         tx: string;
     } | {
@@ -80,7 +80,7 @@ export interface PluginCreateDependenciesResult {
 export interface PluginCreateMetadataResult {
     type: 'createMetadataResult';
     payload: {
-        metadata: ReturnType<LoadedNxPlugin['createMetadata']>;
+        metadata: Awaited<ReturnType<LoadedNxPlugin['createMetadata']>>;
         success: true;
         tx: string;
     } | {

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

@@ -25,6 +25,7 @@ const error_types_1 = require("../error-types");
 const path = require("node:path/posix");
 const typescript_1 = require("../../plugins/js/utils/typescript");
 const load_resolved_plugin_1 = require("./load-resolved-plugin");
+const packages_1 = require("../../plugins/js/utils/packages");
 function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
     try {
         const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
@@ -89,26 +90,32 @@ function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspa
     }
     return { path: path.join(root, projectConfig.root), projectConfig };
 }
+let packageEntryPointsToProjectMap;
 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 = new Map();
+    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
+    const projectRootMappings = new Map();
+    if (possibleTsPaths.length) {
         const projectNameMap = new Map();
         for (const projectRoot in projects) {
             const project = projects[projectRoot];
             projectRootMappings.set(project.root, project.name);
             projectNameMap.set(project.name, project);
         }
-        for (const tsConfigPath of possiblePaths) {
+        for (const tsConfigPath of possibleTsPaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
                 return projectNameMap.get(nxProject);
             }
         }
-        logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
-        throw new Error('Unable to resolve local plugin with import path ' + importPath);
     }
+    packageEntryPointsToProjectMap ??=
+        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    if (packageEntryPointsToProjectMap[importPath]) {
+        return packageEntryPointsToProjectMap[importPath];
+    }
+    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
+    throw new Error('Unable to resolve local plugin with import path ' + importPath);
 }
 let tsconfigPaths;
 function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {

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

@@ -20,6 +20,7 @@ const path_1 = require("path");
 const perf_hooks_1 = require("perf_hooks");
 const error_types_1 = require("../error-types");
 const globs_1 = require("../../utils/globs");
+const delayed_spinner_1 = require("../../utils/delayed-spinner");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -224,6 +225,28 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
 async function createProjectConfigurations(root = workspace_root_1.workspaceRoot, nxJson, projectFiles, // making this parameter allows devkit to pick up newly created projects
 plugins) {
     perf_hooks_1.performance.mark('build-project-configs:start');
+    let spinner;
+    const inProgressPlugins = new Set();
+    function updateSpinner() {
+        if (!spinner) {
+            return;
+        }
+        if (inProgressPlugins.size === 1) {
+            return `Creating project graph nodes with ${inProgressPlugins.keys()[0]}`;
+        }
+        else if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            return [
+                `Creating project graph nodes with ${inProgressPlugins.size} plugins`,
+                ...Array.from(inProgressPlugins).map((p) => `  - ${p}`),
+            ].join('\n');
+        }
+        else {
+            return `Creating project graph nodes with ${inProgressPlugins.size} plugins`;
+        }
+    }
+    if (delayed_spinner_1.SHOULD_SHOW_SPINNERS) {
+        spinner = new delayed_spinner_1.DelayedSpinner(`Creating project graph nodes with ${plugins.length} plugins`);
+    }
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
@@ -233,10 +256,12 @@ plugins) {
             continue;
         }
         const matchingConfigFiles = findMatchingConfigFiles(projectFiles, pattern, include, exclude);
+        inProgressPlugins.add(pluginName);
         let r = createNodes(matchingConfigFiles, {
             nxJsonConfiguration: nxJson,
             workspaceRoot: root,
-        }).catch((e) => {
+        })
+            .catch((e) => {
             const errorBodyLines = [
                 `An error occurred while processing files for the ${pluginName} plugin.`,
             ];
@@ -263,10 +288,15 @@ plugins) {
             errors.push(error);
             // The plugin didn't return partial results, so we return an empty array.
             return error.partialResults.map((r) => [pluginName, r[0], r[1]]);
+        })
+            .finally(() => {
+            inProgressPlugins.delete(pluginName);
+            updateSpinner();
         });
         results.push(r);
     }
     return Promise.all(results).then((results) => {
+        spinner?.cleanup();
         const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');