chore(core): enhance logging and error handling in preset generator

Author: ndcunningham

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

@@ -21,20 +21,28 @@ export function getImplementationFactory<T>(
   const [implementationModulePath, implementationExportName] =
     implementation.split('#');
   return () => {
-    console.log('resolving implementation');
+    console.log(`Resolving implementation: ${implementation} from ${directory}`);
     const modulePath = resolveImplementation(
       implementationModulePath,
       directory,
       packageName,
       projects
     );
+    console.log(`Resolved module path: ${modulePath}`);
     if (extname(modulePath) === '.ts') {
       registerPluginTSTranspiler();
     }
+    try {
     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(
+        `Could not require implementation "${implementation}" from "${directory}". Ensure the implementation is correctly exported.`
+      );
+    }
   };
 }
 
@@ -50,6 +58,9 @@ export function resolveImplementation(
   packageName: string,
   projects: Record<string, ProjectConfiguration>
 ): string {
+  
+  console.log(`Resolving implementation: ${implementationModulePath} from ${directory}`);
+
   const validImplementations = ['', '.js', '.ts'].map(
     (x) => implementationModulePath + x
   );
@@ -66,6 +77,7 @@ export function resolveImplementation(
         projects
       );
       if (maybeImplementationFromSource) {
+        console.log(`Resolved from source: ${maybeImplementationFromSource}`);
         return maybeImplementationFromSource;
       }
     }
@@ -74,17 +86,26 @@ export function resolveImplementation(
   for (const maybeImplementation of validImplementations) {
     const maybeImplementationPath = join(directory, maybeImplementation);
     if (existsSync(maybeImplementationPath)) {
+      console.log(`Resolved from directory: ${maybeImplementationPath}`);
       return maybeImplementationPath;
     }
 
     try {
-      return require.resolve(maybeImplementation, {
+      const resolved = require.resolve(maybeImplementation, {
         paths: [directory],
       });
-    } catch {}
+      console.log(`Resolved via require.resolve: ${resolved}`);
+      return resolved;
+    } 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}".`
   );
 }
@@ -127,14 +148,19 @@ function tryResolveFromSource(
   packageName: string,
   projects: Record<string, ProjectConfiguration>
 ): string | null {
+  console.log(`Trying to resolve from source: ${path} in ${directory} for package: ${packageName}`);
+
   packageToProjectMap ??=
     getWorkspacePackagesMetadata(projects).packageToProjectMap;
   const localProject = packageToProjectMap[packageName];
   if (!localProject) {
-    // it doesn't match any of the package names from the local projects
+    console.log(`No local project found for package: ${packageName}`);
+        // 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}`);
+
   try {
     const fromExports = resolveExports(
       {
@@ -146,13 +172,16 @@ function tryResolveFromSource(
     );
     if (fromExports && fromExports.length) {
       for (const exportPath of fromExports) {
-        if (existsSync(join(directory, exportPath))) {
-          return join(directory, exportPath);
+        const fullPath = join(directory, exportPath);
+        if (existsSync(fullPath)) {
+          console.log(`Resolved from exports: ${fullPath}`);
+          return fullPath;
         }
       }
     }
-  } catch {}
-
+  } catch (e) {
+    console.log(`Failed to resolve from exports: ${e.message}`);
+  }
   /**
    * Fall back to try to "guess" the source by checking the path in some common directories:
    * - the root of the project
@@ -169,6 +198,7 @@ function tryResolveFromSource(
 
     for (const possiblePath of possiblePaths) {
       if (existsSync(possiblePath)) {
+        console.log(`Resolved from fallback path: ${possiblePath}`);
         return possiblePath;
       }
     }

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

@@ -4,16 +4,26 @@ import { Preset } from '../utils/presets';
 import { join } from 'path';
 
 export async function presetGenerator(tree: Tree, options: Schema) {
-  const presetTask = await createPreset(tree, options);
-  return async () => {
-    installPackagesTask(tree);
-    if (presetTask) await presetTask();
-  };
+  
+  console.log(`Running preset generator with preset: ${options.preset} and workspaces: ${options.workspaces}`);
+  
+  try {
+    const presetTask = await createPreset(tree, options);
+    return async () => {
+      installPackagesTask(tree);
+      if (presetTask) await presetTask();
+    };
+  } catch (e) {
+    console.log(`Preset generation error: ${e.stack}`);
+    throw new Error(e);
+  }
 }
 
 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 =