fix(upgrade): recreate selected workspace lockfile

Author: danielroe

packages/nuxt-cli/src/commands/upgrade.ts

@@ -161,19 +161,18 @@ export default defineCommand({
 description: 'Force upgrade to recreate lockfile and node_modules',
 },
 channel: {
-type: 'string',
+type: 'enum',
 alias: 'ch',
 default: 'stable',
 description: 'Specify a channel to install from',
-valueHint: 'stable|nightly|v3|v4|v4-nightly|v3-nightly',
+options: ['stable','nightly','v3','v4','v4-nightly','v3-nightly'],
 },
 },
 asyncrun(ctx){
 constcwd=resolveRootDir(ctx.args)
 
 intro(styleText('cyan','Upgrading Nuxt ...'))
 
-// Check package manager
 const[packageManager,workspaceDir=cwd]=awaitPromise.all([detectPackageManager(cwd),findWorkspaceDir(cwd,{try: true})])
 if(!packageManager){
 logger.error(
@@ -186,19 +185,16 @@ export default defineCommand({
 constpackageManagerVersion=getPackageManagerVersion(packageManagerName)
 logger.step(`Package manager: ${styleText('cyan',packageManagerName)}${packageManagerVersion}`)
 
-// Check currently installed Nuxt version
 constcurrentVersion=(awaitgetNuxtVersion(cwd))||'[unknown]'
 logger.step(`Current Nuxt version: ${styleText('cyan',currentVersion)}`)
 
 constpkg=awaitreadPackageJSON(cwd).catch(()=>null)
 
-// Check if Nuxt is a dependency or devDependency
 constnuxtDependencyType=pkg ? checkNuxtDependencyType(pkg) : 'dependencies'
 constcorePackages=['@nuxt/kit','@nuxt/schema','@nuxt/vite-builder','@nuxt/webpack-builder','@nuxt/rspack-builder']
 
 constpackagesToUpdate=pkg ? corePackages.filter(p=>pkg.dependencies?.[p]||pkg.devDependencies?.[p]) : []
 
-// Install latest version
 constpackageNames=['nuxt', ...packagesToUpdate]
 const{ npmPackages, nuxtVersion }=awaitgetRequiredNewVersion(packageNames,ctx.args.channel)
 
@@ -217,7 +213,6 @@ export default defineCommand({
 }
 }
 
-// Force install
 consttoRemove=['node_modules']
 
 constlockFile=findLockFile(cwd,workspaceDir,lockFileCandidates)
@@ -280,13 +275,15 @@ export default defineCommand({
 constresolved: Array<{catalog: string,pkg: string,specifier: string}>=[]
 constunresolved: string[]=[]
 
-for(const{ catalog, current, spec }ofcatalogUpdates){
-constspecifier=awaitresolveCatalogSpecifier(spec,current)
-if(!specifier){
+constspecifiers=awaitPromise.all(catalogUpdates.map(({ current, spec })=>resolveCatalogSpecifier(spec,current)))
+for(const[index,specifier]ofspecifiers.entries()){
+const{ catalog, spec }=catalogUpdates[index]!
+if(specifier){
+resolved.push({ catalog,pkg: spec.name, specifier })
+}
+else{
 unresolved.push(spec.name)
-continue
 }
-resolved.push({ catalog,pkg: spec.name, specifier })
 }
 
 if(resolved.length>0){
@@ -347,7 +344,7 @@ export default defineCommand({
 recreateLockfile ? `Recreating ${forceRemovals}` : 'Deduping dependencies',
 recreateLockfile ? 'Lockfile recreated' : 'Dependencies deduped',
 { verbose },
-hooks=>runDedupe({ cwd, packageManager, recreateLockfile, ...hooks}),
+hooks=>runDedupe({ cwd, packageManager, recreateLockfile,lockFile,...hooks}),
 )
 
 if(failed){
@@ -373,7 +370,6 @@ export default defineCommand({
 logger.info(`If you encounter any issues, revert the changes and try with ${styleText('cyan','--no-force')}`)
 }
 
-// Check installed Nuxt version again
 constupgradedVersion=(awaitgetNuxtVersion(cwd))||'[unknown]'
 
 if(upgradedVersion==='[unknown]'){
@@ -450,7 +446,6 @@ async function withInstallSpinner(
 return!result.success
 }
 
-// Find which lock file is in use since `nypm.detectPackageManager` doesn't return this
 exportfunctionfindLockFile(cwd: string,workspaceDir: string,lockFiles: string|Array<string>|undefined){
 constcandidates=typeoflockFiles==='string' ? [lockFiles] : lockFiles
 

packages/nuxt-cli/src/utils/install.ts

@@ -3,7 +3,7 @@ import type { ChildProcess, SpawnOptions } from 'node:child_process'
 
 importtype{PackageManager,PackageManagerName}from'nypm'
 import{spawn}from'node:child_process'
-import{statSync}from'node:fs'
+import{rmSync,statSync}from'node:fs'
 import{delimiter,resolve}from'node:path'
 importprocessfrom'node:process'
 
@@ -108,19 +108,31 @@ export async function runInstall(options: InstallOptions): Promise<InstallResult
 }
 
 exportinterfaceDedupeOptionsextendsOmit<InstallOptions,'dependencies'|'dev'|'workspace'>{
-/** Delete the lockfile and resolve dependencies from scratch. */
+/** Delete node_modules and the lockfile, then resolve dependencies from scratch. */
 recreateLockfile?: boolean
+/** Lockfile path relative to cwd. */
+lockFile?: string
 }
 
 /**
  * Dedupe a project's dependencies, or recreate its lockfile, with the same quiet
  * output handling as {@link runInstall}.
  */
 exportasyncfunctionrunDedupe(options: DedupeOptions): Promise<InstallResult>{
+if(options.recreateLockfile){
+rmSync(resolve(options.cwd,'node_modules'),{recursive: true,force: true})
+constlockFiles=options.lockFile
+ ? [options.lockFile]
+ : [options.packageManager.lockFile].flat().filter(Boolean)asstring[]
+for(constlockFileoflockFiles){
+rmSync(resolve(options.cwd,lockFile),{force: true})
+}
+returnawaitrunInstall(options)
+}
+
 const{ exec }=awaitdedupeDependencies({
 cwd: options.cwd,
 packageManager: options.packageManager,
-recreateLockfile: options.recreateLockfile,
 dry: true,
 })
 

packages/nuxt-cli/test/unit/utils/install.spec.ts

@@ -1,5 +1,5 @@
 import{existsSync}from'node:fs'
-import{chmod,mkdtemp,writeFile}from'node:fs/promises'
+import{chmod,mkdir,mkdtemp,writeFile}from'node:fs/promises'
 import{tmpdir}from'node:os'
 import{join}from'node:path'
 importprocessfrom'node:process'
@@ -135,20 +135,28 @@ describe('runDedupe', () => {
 expect(lines).toEqual(['all done'])
 })
 
-it.skipIf(process.platform==='win32')('should install after removing the lockfile when recreating it',async()=>{
+it.skipIf(process.platform==='win32')('should install after removing node_modules and the selected lockfile',async()=>{
 const{ dir, command }=awaitcreateFakePackageManager()
-constlockFile=join(dir,'pnpm-lock.yaml')
-awaitwriteFile(lockFile,'lockfileVersion: 9.0\n')
+constappDir=join(dir,'app')
+constnodeModules=join(appDir,'node_modules')
+constlocalLockFile=join(appDir,'pnpm-lock.yaml')
+constworkspaceLockFile=join(dir,'pnpm-lock.yaml')
+awaitmkdir(nodeModules,{recursive: true})
+awaitwriteFile(localLockFile,'lockfileVersion: 9.0\n')
+awaitwriteFile(workspaceLockFile,'lockfileVersion: 9.0\n')
 
 constresult=awaitrunDedupe({
-cwd: dir,
+cwd: appDir,
 packageManager: {name: 'pnpm', command,lockFile: 'pnpm-lock.yaml'},
 recreateLockfile: true,
+lockFile: '../pnpm-lock.yaml',
 })
 
 expect(result.success).toBe(true)
 expect(result.command).toContain(`${command} install`)
-expect(existsSync(lockFile)).toBe(false)
+expect(existsSync(nodeModules)).toBe(false)
+expect(existsSync(workspaceLockFile)).toBe(false)
+expect(existsSync(localLockFile)).toBe(true)
 })
 
 it('should report a missing package manager instead of throwing',async()=>{