fix: use ["workspaces", "list", "--json"] instead of workspaceRoot for yarn v2+ package manager (#9415)

Author: mmaietta

.changeset/tall-needles-join.md

@@ -0,0 +1,5 @@
+---
+"app-builder-lib": patch
+---
+
+fix: use `projectRoot` instead of `workspaceRoot` for yarn_berry package manager

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

@@ -8,7 +8,7 @@ import { YarnBerryNodeModulesCollector } from "./yarnBerryNodeModulesCollector"
 import { YarnNodeModulesCollector } from "./yarnNodeModulesCollector"
 import { BunNodeModulesCollector } from "./bunNodeModulesCollector"
 import { Lazy } from "lazy-val"
-import { spawn, log } from "builder-util"
+import { spawn, log, exists } from "builder-util"
 import * as fs from "fs-extra"
 import * as path from "path"
 
@@ -55,6 +55,10 @@ export const determinePackageManagerEnv = ({ projectDir, appDir, workspaceRoot }
     if (root != null) {
       // re-detect package manager from workspace root, this seems particularly necessary for pnpm workspaces
       const actualPm = await detectPackageManager([root])
+      log.info(
+        { pm: actualPm.pm, config: actualPm.corepackConfig, resolved: actualPm.resolvedDirectory, projectDir },
+        `detected workspace root for project using ${actualPm.detectionMethod}`
+      )
       return {
         pm: actualPm.pm,
         workspaceRoot: Promise.resolve(actualPm.resolvedDirectory),
@@ -67,55 +71,65 @@ export const determinePackageManagerEnv = ({ projectDir, appDir, workspaceRoot }
   })
 
 async function findWorkspaceRoot(pm: PM, cwd: string): Promise<string | undefined> {
-  let command: { command: string; args: string[] } | undefined
+  let command: { command: string; args: string[] }
 
   switch (pm) {
     case PM.PNPM:
       command = { command: "pnpm", args: ["--workspace-root", "exec", "pwd"] }
       break
-
     case PM.YARN_BERRY:
-      command = { command: "yarn", args: ["config", "get", "workspaceRoot"] }
+      command = { command: "yarn", args: ["workspaces", "list", "--json"] }
       break
-
     case PM.YARN: {
       command = { command: "yarn", args: ["workspaces", "info", "--silent"] }
       break
     }
-
     case PM.BUN:
       command = { command: "bun", args: ["pm", "ls", "--json"] }
       break
-
     case PM.NPM:
     default:
       command = { command: "npm", args: ["prefix", "-w"] }
       break
   }
 
   const output = await spawn(command.command, command.args, { cwd, stdio: ["ignore", "pipe", "ignore"] })
-    .then(it => {
-      const out = it?.trim()
+    .then(async it => {
+      const out: string | undefined = it?.trim()
+      if (!out) {
+        return undefined
+      }
       if (pm === PM.YARN) {
         JSON.parse(out) // if JSON valid, workspace detected
-        return findNearestWithWorkspacesField(cwd)
+        return findNearestPackageJsonWithWorkspacesField(cwd)
       } else if (pm === PM.BUN) {
         const json = JSON.parse(out)
         if (Array.isArray(json) && json.length > 0) {
-          return findNearestWithWorkspacesField(cwd)
+          return findNearestPackageJsonWithWorkspacesField(cwd)
+        }
+      } else if (pm === PM.YARN_BERRY) {
+        const lines = out
+          .split("\n")
+          .map(l => l.trim())
+          .filter(Boolean)
+        for (const line of lines) {
+          const parsed = JSON.parse(line)
+          if (parsed.location != null) {
+            const potential = path.resolve(cwd, parsed.location)
+            return (await exists(potential)) ? findNearestPackageJsonWithWorkspacesField(potential) : undefined
+          }
         }
       }
-      return !out?.length || out === "undefined" ? undefined : out
+      return out.length === 0 || out === "undefined" ? undefined : out
     })
-    .catch(() => findNearestWithWorkspacesField(cwd))
-
-  log.debug({ root: output || cwd }, output ? "workspace root detected" : "workspace root not detected, using project root")
+    .catch(() => findNearestPackageJsonWithWorkspacesField(cwd))
   return output
 }
 
-async function findNearestWithWorkspacesField(dir: string): Promise<string | undefined> {
+async function findNearestPackageJsonWithWorkspacesField(dir: string): Promise<string | undefined> {
   let current = dir
   while (true) {
+    log.debug({ path: current }, "checking for potential workspace root")
     const pkgPath = path.join(current, "package.json")
     try {
       const pkg = JSON.parse(await fs.readFile(pkgPath, "utf8"))

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

@@ -122,9 +122,10 @@ export class NpmNodeModulesCollector extends NodeModulesCollector<NpmDependency,
 
           if (!resolvedPackage) {
             log.warn({ package: pkg.name, dependency: depName, version: depVersion }, "dependency not found")
+            continue
           }
 
-          const resolvedDepPath = await this.resolvePath(resolvedPackage!.packageDir)
+          const resolvedDepPath = await this.resolvePath(resolvedPackage.packageDir)
           // Skip if this dependency resolves to the base directory or any parent we're already processing
           if (resolvedDepPath === resolvedPackageDir || resolvedDepPath === (await this.resolvePath(baseDir))) {
             log.debug({ package: pkg.name, dependency: depName, resolvedPath: resolvedDepPath }, "skipping self-referential dependency")

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

@@ -45,7 +45,14 @@ export function getPackageManagerCommand(pm: PM) {
   return resolved
 }
 
-export async function detectPackageManager(searchPaths: string[]): Promise<{ pm: PM; corepackConfig: string | undefined; resolvedDirectory: string | undefined }> {
+type PackageManagerSetup = {
+  pm: PM
+  corepackConfig: string | undefined
+  resolvedDirectory: string | undefined
+  detectionMethod: string
+}
+
+export async function detectPackageManager(searchPaths: string[]): Promise<PackageManagerSetup> {
   let pm: PM | null = null
   const dedupedPaths = Array.from(new Set(searchPaths)) // reduce file operations, dedupe paths since primary use case has projectDir === appDir
 
@@ -58,24 +65,22 @@ export async function detectPackageManager(searchPaths: string[]): Promise<{ pm:
       const [pm, version] = packageManager.split("@")
       if (Object.values(PM).includes(pm as PM)) {
         const resolvedPackageManager = await resolveIfYarn(pm as PM, version, dir)
-        log.info({ resolvedPackageManager, packageManager, cwd: dir }, "packageManager field detected in package.json")
-        return { pm: resolvedPackageManager, corepackConfig: packageManager, resolvedDirectory: dir }
+        return { pm: resolvedPackageManager, corepackConfig: packageManager, resolvedDirectory: dir, detectionMethod: "packageManager field" }
       }
     }
 
     pm = await detectPackageManagerByFile(dir)
     if (pm) {
       const resolvedPackageManager = await resolveIfYarn(pm, "", dir)
-      log.info({ resolvedPackageManager, cwd: dir }, "packageManager detected by file")
-      return { pm: resolvedPackageManager, resolvedDirectory: dir, corepackConfig: undefined }
+      return { pm: resolvedPackageManager, resolvedDirectory: dir, corepackConfig: undefined, detectionMethod: "lock file" }
     }
   }
 
   pm = detectPackageManagerByEnv() || PM.NPM
   const cwd = process.env.npm_package_json ? path.dirname(process.env.npm_package_json) : (process.env.INIT_CWD ?? process.cwd())
   const resolvedPackageManager = await resolveIfYarn(pm, "", cwd)
   log.info({ resolvedPackageManager, detected: cwd }, "packageManager not detected by file, falling back to environment detection")
-  return { pm: resolvedPackageManager, resolvedDirectory: undefined, corepackConfig: undefined }
+  return { pm: resolvedPackageManager, resolvedDirectory: undefined, corepackConfig: undefined, detectionMethod: "process environment" }
 }
 
 function detectPackageManagerByEnv(): PM | null {

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

@@ -39,7 +39,7 @@ export class PnpmNodeModulesCollector extends NodeModulesCollector<PnpmDependenc
     const pkgJsonPath = await this.resolvePackage(packageName, depTree.path)
 
     if (pkgJsonPath == null) {
-      log.warn({ packageName, path: depTree.path, version: depTree.version }, `Cannot find package.json for dependency`)
+      log.debug({ packageName, path: depTree.path, version: depTree.version }, `Cannot find package.json for dependency`)
       return { path: depTree.path, prodDeps: {}, optionalDependencies: {} }
     }
     let packageJson: PackageJson

packages/app-builder-lib/src/util/appFileCopier.ts

@@ -194,6 +194,10 @@ export async function computeNodeModuleFileSets(platformPackager: PlatformPackag
       deps = dirDeps
       break
     }
+    const attempt = searchDirectories.indexOf(dir)
+    if (attempt < searchDirectories.length - 1) {
+      log.info({ searchDir: dir, attempt }, "no node modules found in collection, trying next search directory")
+    }
   }
   if (deps.length === 0) {
     log.warn({ searchDirectories: searchDirectories.map(it => log.filePath(it)) }, "no node modules returned while searching directories")