chore(plugin): add logging for package.json reading

Author: ndcunningham

packages/nx/src/config/schema-utils.ts

@@ -21,7 +21,9 @@ export function getImplementationFactory<T>(
   const [implementationModulePath, implementationExportName] =
     implementation.split('#');
   return () => {
-    console.log(`Resolving implementation: ${implementation} from ${directory}`);
+    console.log(
+      `Resolving implementation: ${implementation} from ${directory}`
+    );
     const modulePath = resolveImplementation(
       implementationModulePath,
       directory,
@@ -33,10 +35,10 @@ export function getImplementationFactory<T>(
       registerPluginTSTranspiler();
     }
     try {
-    const module = require(modulePath);
-    return implementationExportName
-      ? module[implementationExportName]
-      : module.default ?? module;
+      const module = require(modulePath);
+      return implementationExportName
+        ? module[implementationExportName]
+        : module.default ?? module;
     } catch (e) {
       console.error(`Failed to require implementation at ${modulePath}:`, e);
       throw new Error(
@@ -58,8 +60,9 @@ export function resolveImplementation(
   packageName: string,
   projects: Record<string, ProjectConfiguration>
 ): string {
-  
-  console.log(`Resolving implementation: ${implementationModulePath} from ${directory}`);
+  console.log(
+    `Resolving implementation: ${implementationModulePath} from ${directory}`
+  );
 
   const validImplementations = ['', '.js', '.ts'].map(
     (x) => implementationModulePath + x
@@ -96,16 +99,19 @@ export function resolveImplementation(
       });
       console.log(`Resolved via require.resolve: ${resolved}`);
       return resolved;
-    } catch(e) {
-      console.error(`Failed to resolve "${maybeImplementation}" from "${directory}":`, e);
+    } catch (e) {
+      console.error(
+        `Failed to resolve "${maybeImplementation}" from "${directory}":`,
+        e
+      );
       // If it fails, we continue to the next valid implementation
       // This is useful for cases where the implementation might be in a different format
       // or if the file is not found in the expected location.
       continue;
     }
   }
 
-throw new Error(
+  throw new Error(
     `Could not resolve "${implementationModulePath}" from "${directory}".`
   );
 }
@@ -148,18 +154,22 @@ function tryResolveFromSource(
   packageName: string,
   projects: Record<string, ProjectConfiguration>
 ): string | null {
-  console.log(`Trying to resolve from source: ${path} in ${directory} for package: ${packageName}`);
+  console.log(
+    `Trying to resolve from source: ${path} in ${directory} for package: ${packageName}`
+  );
 
   packageToProjectMap ??=
     getWorkspacePackagesMetadata(projects).packageToProjectMap;
   const localProject = packageToProjectMap[packageName];
   if (!localProject) {
     console.log(`No local project found for package: ${packageName}`);
-        // it doesn't match any of the package names from the local projects
+    // it doesn't match any of the package names from the local projects
     return null;
   }
 
-  console.log(`Found local project for package: ${packageName} at ${localProject.root}`);
+  console.log(
+    `Found local project for package: ${packageName} at ${localProject.root}`
+  );
 
   try {
     const fromExports = resolveExports(

packages/nx/src/project-graph/plugins/in-process-loader.ts

@@ -19,6 +19,7 @@ import {
   pluginTranspilerIsRegistered,
   registerPluginTSTranspiler,
 } from './transpiler';
+import { workspaceRoot } from '@nx/devkit';
 
 export function readPluginPackageJson(
   pluginName: string,
@@ -28,20 +29,33 @@ export function readPluginPackageJson(
   path: string;
   json: PackageJson;
 } {
+  console.log(
+    `Reading plugin package.json for: ${pluginName} from paths: ${paths} at root: ${workspaceRoot}`
+  );
   try {
     const result = readModulePackageJsonWithoutFallbacks(pluginName, paths);
+    console.log(
+      `Found package.json via readModulePackageJsonWithoutFallbacks at: ${result.path}`
+    );
     return {
       json: result.packageJson,
       path: result.path,
     };
   } catch (e) {
+    console.log(
+      `readModulePackageJsonWithoutFallbacks failed for ${pluginName}:`,
+      e.message
+    );
     if (e.code === 'MODULE_NOT_FOUND') {
       const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
       if (localPluginPath) {
         const localPluginPackageJson = path.join(
           localPluginPath.path,
           'package.json'
         );
+        console.log(
+          `Falling back to local plugin at: ${localPluginPackageJson}`
+        );
         if (!pluginTranspilerIsRegistered()) {
           registerPluginTSTranspiler();
         }

packages/workspace/src/generators/preset/preset.ts

@@ -4,9 +4,10 @@ import { Preset } from '../utils/presets';
 import { join } from 'path';
 
 export async function presetGenerator(tree: Tree, options: Schema) {
-  
-  console.log(`Running preset generator with preset: ${options.preset} and workspaces: ${options.workspaces}`);
-  
+  console.log(
+    `Running preset generator with preset: ${options.preset} and workspaces: ${options.workspaces}`
+  );
+
   try {
     const presetTask = await createPreset(tree, options);
     return async () => {
@@ -23,7 +24,7 @@ export default presetGenerator;
 
 async function createPreset(tree: Tree, options: Schema) {
   console.log(`Creating preset: ${options.preset}`);
-  
+
   console.log('reading nx.json');
   const nxJson = readNxJson(tree);
   const addPlugin =