fix: search for actual path in hoisted mode for pnpm since it can still return virtual paths via CLI (#9392)

Author: mmaietta

.changeset/tall-lions-cry.md

@@ -0,0 +1,5 @@
+---
+"app-builder-lib": patch
+---
+
+fix: returning actual path in hoisted mode for pnpm since it can still return virtual paths

packages/app-builder-lib/src/node-module-collector/nodeModulesCollector.ts

@@ -172,6 +172,20 @@ export abstract class NodeModulesCollector<ProdDepType extends Dependency<ProdDe
     return this.cache.realPath.get(filePath)!
   }
 
+  protected requireMemoized(pkgPath: string): PackageJson {
+    if (!this.cache.packageJson.has(pkgPath)) {
+      this.cache.packageJson.set(pkgPath, require(pkgPath))
+    }
+    return this.cache.packageJson.get(pkgPath)!
+  }
+
+  protected existsSyncMemoized(filePath: string): boolean {
+    if (!this.cache.exists.has(filePath)) {
+      this.cache.exists.set(filePath, fs.existsSync(filePath))
+    }
+    return this.cache.exists.get(filePath)!
+  }
+
   protected async resolvePath(filePath: string): Promise<string> {
     // Check if we've already resolved this path
     if (this.cache.realPath.has(filePath)) {
@@ -211,15 +225,17 @@ export abstract class NodeModulesCollector<ProdDepType extends Dependency<ProdDe
         try {
           const url = (await this.importMetaResolve.value)(packageName, pathToFileURL(fromDir).href)
           return url.startsWith("file://") ? fileURLToPath(url) : null
-        } catch {
+        } catch (error: any) {
+          log.debug({ error: error.message }, "import-meta-resolve failed")
           // ignore
         }
       }
 
       // 2) Fallback: require.resolve (CJS, old packages)
       try {
         return require.resolve(packageName, { paths: [fromDir, this.rootDir] })
-      } catch {
+      } catch (error: any) {
+        log.debug({ error: error.message }, "require.resolve failed")
         // ignore
       }
 
@@ -236,7 +252,7 @@ export abstract class NodeModulesCollector<ProdDepType extends Dependency<ProdDe
     let dir = path.dirname(entry)
     while (true) {
       const pkgFile = path.join(dir, "package.json")
-      if (await exists(pkgFile)) {
+      if (await this.existsMemoized(pkgFile)) {
         this.cache.requireResolve.set(cacheKey, dir)
         return dir
       }
@@ -252,20 +268,6 @@ export abstract class NodeModulesCollector<ProdDepType extends Dependency<ProdDe
     return null
   }
 
-  protected requireMemoized(pkgPath: string): PackageJson {
-    if (!this.cache.packageJson.has(pkgPath)) {
-      this.cache.packageJson.set(pkgPath, require(pkgPath))
-    }
-    return this.cache.packageJson.get(pkgPath)!
-  }
-
-  protected existsSyncMemoized(filePath: string): boolean {
-    if (!this.cache.exists.has(filePath)) {
-      this.cache.exists.set(filePath, fs.existsSync(filePath))
-    }
-    return this.cache.exists.get(filePath)!
-  }
-
   protected cacheKey(pkg: ProdDepType): string {
     const rel = path.relative(this.rootDir, pkg.path)
     return `${pkg.name}::${pkg.version}::${rel ?? "."}`
@@ -296,7 +298,7 @@ export abstract class NodeModulesCollector<ProdDepType extends Dependency<ProdDe
 
     if (tree.dependencies?.[packageName]) {
       const { name, path, dependencies } = tree.dependencies[packageName]
-      log.debug({ name, path, dependencies: JSON.stringify(dependencies) }, "pruning root app/self package from workspace tree")
+      log.debug({ name, path, dependencies: JSON.stringify(dependencies) }, "pruning root app/self reference from workspace tree")
       for (const [name, pkg] of Object.entries(dependencies ?? {})) {
         tree.dependencies[name] = pkg
       }

packages/app-builder-lib/src/node-module-collector/pnpmNodeModulesCollector.ts

@@ -11,78 +11,95 @@ export class PnpmNodeModulesCollector extends NodeModulesCollector<PnpmDependenc
   }
 
   protected getArgs(): string[] {
-    return ["list", "--prod", "--json", "--depth", "Infinity"]
+    return ["list", "--prod", "--json", "--depth", "Infinity", "--long"]
   }
 
-  protected async extractProductionDependencyGraph(tree: PnpmDependency, dependencyId: string) {
-    if (this.productionGraph[dependencyId]) {
-      return
-    }
-
-    const getProductionDependencies = async (depTree: PnpmDependency): Promise<{ prodDeps: Record<string, string>; optionalDependencies: Record<string, string> } | null> => {
+  private async resolveActualPath(depTree: PnpmDependency): Promise<string> {
+    // If using hoisted mode, try to find the package at the hoisted location first
+    if (await this.isHoisted.value) {
       const packageName = depTree.name || depTree.from
-      if (isEmptyOrSpaces(packageName)) {
-        log.error(depTree, `Cannot determine production dependencies for package with empty name`)
-        throw new Error(`Cannot compute production dependencies for package with empty name: ${packageName}`)
+      if (packageName) {
+        const hoistedPath = path.join(this.rootDir, "node_modules", packageName)
+        if (await this.existsMemoized(hoistedPath)) {
+          return hoistedPath
+        }
       }
+    }
+    // Fall back to the reported path (which might be the .pnpm store path)
+    return depTree.path
+  }
 
-      const p = path.normalize((await this.resolvePackageDir(packageName, depTree.path)) ?? (await this.resolvePath(depTree.path)))
-      const pkgJsonPath = path.join(p, "package.json")
+  private async getProductionDependencies(depTree: PnpmDependency): Promise<{ path: string; prodDeps: Record<string, string>; optionalDependencies: Record<string, string> }> {
+    const packageName = depTree.name || depTree.from
+    if (isEmptyOrSpaces(packageName)) {
+      log.error(depTree, `Cannot determine production dependencies for package with empty name`)
+      throw new Error(`Cannot compute production dependencies for package with empty name: ${packageName}`)
+    }
 
-      let packageJson: PackageJson
-      try {
-        packageJson = this.requireMemoized(pkgJsonPath)
-      } catch (error: any) {
-        log.warn(null, `Failed to read package.json for ${p}: ${error.message}`)
-        return null
-      }
-      return { prodDeps: { ...packageJson.dependencies, ...packageJson.optionalDependencies }, optionalDependencies: { ...packageJson.optionalDependencies } }
+    const actualPath = await this.resolveActualPath(depTree)
+    const resolvedLocalPath = await this.resolvePath(actualPath)
+    const p = path.normalize(resolvedLocalPath)
+    const pkgJsonPath = path.join(p, "package.json")
+
+    let packageJson: PackageJson
+    try {
+      packageJson = this.requireMemoized(pkgJsonPath)
+    } catch (error: any) {
+      log.warn(null, `Failed to read package.json for ${p}: ${error.message}`)
+      return { path: p, prodDeps: {}, optionalDependencies: {} }
+    }
+    return { path: p, prodDeps: { ...packageJson.dependencies, ...packageJson.optionalDependencies }, optionalDependencies: { ...packageJson.optionalDependencies } }
+  }
+
+  protected async extractProductionDependencyGraph(tree: PnpmDependency, dependencyId: string) {
+    if (this.productionGraph[dependencyId]) {
+      return
     }
 
     const packageName = tree.name || tree.from
-    const json = packageName === dependencyId ? null : await getProductionDependencies(tree)
+    const json = packageName === dependencyId ? null : await this.getProductionDependencies(tree)
     const prodDependencies = json?.prodDeps ?? { ...(tree.dependencies || {}), ...(tree.optionalDependencies || {}) }
     if (prodDependencies == null) {
       this.productionGraph[dependencyId] = { dependencies: [] }
       return
     }
     const deps = { ...(tree.dependencies || {}), ...(tree.optionalDependencies || {}) }
     this.productionGraph[dependencyId] = { dependencies: [] }
-    const depPromises = Object.entries(deps)
-      .filter(([packageName, dependency]) => {
-        // First check if it's in production dependencies
-        if (!prodDependencies[packageName]) {
-          return false
-        }
+    const depPromises = Object.entries(deps).map(async ([packageName, dependency]) => {
+      // First check if it's in production dependencies
+      if (!prodDependencies[packageName]) {
+        return undefined
+      }
 
-        // Then check if optional dependency path exists (using memoized version)
-        if (json?.optionalDependencies?.[packageName] && !this.existsSyncMemoized(dependency.path)) {
-          log.debug(null, `Optional dependency ${packageName}@${dependency.version} path doesn't exist: ${dependency.path}`)
-          return false
+      // Then check if optional dependency path exists (using actual resolved path)
+      if (json?.optionalDependencies?.[packageName]) {
+        const actualPath = await this.resolveActualPath(dependency)
+        if (!(await this.existsMemoized(actualPath))) {
+          log.debug(null, `Optional dependency ${packageName}@${dependency.version} path doesn't exist: ${actualPath}`)
+          return undefined
         }
+      }
+      const childDependencyId = this.packageVersionString(dependency)
+      await this.extractProductionDependencyGraph(dependency, childDependencyId)
+      return childDependencyId
+    })
 
-        return true
-      })
-      .map(async ([, dependency]) => {
-        const childDependencyId = this.packageVersionString(dependency)
-        await this.extractProductionDependencyGraph(dependency, childDependencyId)
-        return childDependencyId
-      })
-
-    const dependencies = await Promise.all(depPromises)
+    const dependencies = (await Promise.all(depPromises)).filter((id): id is string => id !== undefined)
     this.productionGraph[dependencyId] = { dependencies }
   }
 
   protected async collectAllDependencies(tree: PnpmDependency) {
     // Collect regular dependencies
     for (const [key, value] of Object.entries(tree.dependencies || {})) {
-      this.allDependencies.set(`${key}@${value.version}`, value)
+      const json = await this.getProductionDependencies(value)
+      this.allDependencies.set(`${key}@${value.version}`, { ...value, path: json.path })
       await this.collectAllDependencies(value)
     }
 
     // Collect optional dependencies if they exist
     for (const [key, value] of Object.entries(tree.optionalDependencies || {})) {
-      this.allDependencies.set(`${key}@${value.version}`, value)
+      const json = await this.getProductionDependencies(value)
+      this.allDependencies.set(`${key}@${value.version}`, { ...value, path: json.path })
       await this.collectAllDependencies(value)
     }
   }

packages/app-builder-lib/src/node-module-collector/yarnNodeModulesCollector.ts

@@ -123,8 +123,8 @@ export class YarnNodeModulesCollector extends NodeModulesCollector<YarnDependenc
 
     const rootPkgJson = await this.appPkgJson.value
     return Promise.resolve({
-      name: rootPkgJson?.name || ".",
-      version: rootPkgJson?.version || "unknown",
+      name: rootPkgJson.name,
+      version: rootPkgJson.version,
       path: this.rootDir,
       dependencies,
       workspaces: rootPkgJson?.workspaces,