fix(upgrade): take ownership of dependency installation

Author: danielroe

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

@@ -1,15 +1,18 @@
 importtype{PackageJson}from'pkg-types'
 
+importtype{InstallResult}from'../utils/install'
+
 import{existsSync}from'node:fs'
 importprocessfrom'node:process'
 
-import{cancel,intro,isCancel,note,outro,select,spinner,tasks}from'@clack/prompts'
+import{cancel,intro,isCancel,note,outro,select,spinner}from'@clack/prompts'
 import{defineCommand}from'citty'
-import{addDependency,dedupeDependencies,detectPackageManager}from'nypm'
+import{detectPackageManager}from'nypm'
 import{dirname,relative,resolve}from'pathe'
 importcolorsfrom'picocolors'
 import{findWorkspaceDir,readPackageJSON}from'pkg-types'
 
+import{createInstallLog,runDedupe,runInstall,takeUnreportedIgnoredBuilds}from'../utils/install'
 import{loadKit}from'../utils/kit'
 import{logger}from'../utils/logger'
 import{cleanupNuxtDirs,nuxtVersionToGitIdentifier}from'../utils/nuxt'
@@ -188,59 +191,53 @@ export default defineCommand({
 
 constversionType=ctx.args.channel==='nightly' ? 'nightly' : `latest ${ctx.args.channel}`
 
-constspin=spinner()
-spin.start('Upgrading Nuxt')
-
-awaittasks([
-{
-title: `Installing ${versionType} Nuxt ${nuxtVersion} release`,
-task: async()=>{
-awaitaddDependency(npmPackages,{
- cwd,
- packageManager,
-dev: nuxtDependencyType==='devDependencies',
-workspace: packageManager?.name==='pnpm'&&existsSync(resolve(cwd,'pnpm-workspace.yaml')),
-})
-return'Nuxt packages installed'
-},
-},
- ...(method==='force'
- ? [{
-title: `Recreating ${forceRemovals}`,
-task: async()=>{
-awaitdedupeDependencies({recreateLockfile: true})
-return'Lockfile recreated'
-},
-}]
- : []),
- ...(method==='dedupe'
- ? [{
-title: 'Deduping dependencies',
-task: async()=>{
-awaitdedupeDependencies()
-return'Dependencies deduped'
-},
-}]
- : []),
-{
-title: 'Cleaning up build directories',
-task: async()=>{
-letbuildDir: string='.nuxt'
-try{
-const{ loadNuxtConfig }=awaitloadKit(cwd)
-constnuxtOptions=awaitloadNuxtConfig({ cwd })
-buildDir=nuxtOptions.buildDir
-}
-catch{
-// Use default buildDir (.nuxt)
-}
-awaitcleanupNuxtDirs(cwd,buildDir)
-return'Build directories cleaned'
-},
-},
-])
-
-spin.stop()
+constverbose=ctx.args.logLevel==='verbose'||Boolean(process.env.DEBUG)
+
+constinstallFailed=awaitwithInstallSpinner(
+`Installing ${versionType} Nuxt ${nuxtVersion} release`,
+'Nuxt packages installed',
+{ verbose },
+hooks=>runInstall({
+ cwd,
+ packageManager,
+dependencies: npmPackages,
+dev: nuxtDependencyType==='devDependencies',
+workspace: packageManager.name==='pnpm'&&existsSync(resolve(cwd,'pnpm-workspace.yaml')),
+ ...hooks,
+}),
+)
+
+if(installFailed){
+process.exit(1)
+}
+
+if(method==='force'||method==='dedupe'){
+constrecreateLockfile=method==='force'
+constfailed=awaitwithInstallSpinner(
+recreateLockfile ? `Recreating ${forceRemovals}` : 'Deduping dependencies',
+recreateLockfile ? 'Lockfile recreated' : 'Dependencies deduped',
+{ verbose },
+hooks=>runDedupe({ cwd, packageManager, recreateLockfile, ...hooks}),
+)
+
+if(failed){
+process.exit(1)
+}
+}
+
+constcleanupSpinner=spinner()
+cleanupSpinner.start('Cleaning up build directories')
+letbuildDir: string='.nuxt'
+try{
+const{ loadNuxtConfig }=awaitloadKit(cwd)
+constnuxtOptions=awaitloadNuxtConfig({ cwd })
+buildDir=nuxtOptions.buildDir
+}
+catch{
+// Use default buildDir (.nuxt)
+}
+awaitcleanupNuxtDirs(cwd,buildDir,{silent: true})
+cleanupSpinner.stop('Build directories cleaned')
 
 if(method==='force'){
 logger.info(`If you encounter any issues, revert the changes and try with ${colors.cyan('--no-force')}`)
@@ -276,6 +273,53 @@ export default defineCommand({
 },
 })
 
+interfaceInstallHooks{
+onOutput: (line: string)=>void
+onStatus: (message: string)=>void
+signal: AbortSignal
+}
+
+/**
+ * Run a package manager step behind a spinner, surfacing its output only when it
+ * fails (or when running verbosely). Returns whether the step failed.
+ */
+asyncfunctionwithInstallSpinner(
+title: string,
+success: string,
+options: {verbose: boolean},
+run: (hooks: InstallHooks)=>Promise<InstallResult>,
+): Promise<boolean>{
+constcontroller=newAbortController()
+constinstallLog=createInstallLog({verbose: options.verbose})
+constspin=spinner({
+indicator: 'timer',
+onCancel: ()=>controller.abort(),
+})
+
+spin.start(title)
+constresult=awaitrun({
+onOutput: installLog.onOutput,
+onStatus: message=>spin.message(message),
+signal: controller.signal,
+})
+
+if(result.success){
+spin.stop(success)
+}
+else{
+spin.error(result.error??`${title} failed`)
+}
+
+installLog.finish(result)
+
+constignoredBuilds=takeUnreportedIgnoredBuilds(result.ignoredBuilds)
+if(ignoredBuilds.length>0){
+logger.warn(`Build scripts were not run for ${ignoredBuilds.map(name=>colors.cyan(name)).join(', ')}.`)
+}
+
+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

@@ -8,7 +8,7 @@ import { delimiter, resolve } from 'node:path'
 importprocessfrom'node:process'
 
 import{log,S_BAR}from'@clack/prompts'
-import{addDependency,installDependencies,packageManagers}from'nypm'
+import{addDependency,dedupeDependencies,installDependencies,packageManagers}from'nypm'
 importcolorsfrom'picocolors'
 import{provider}from'std-env'
 import{normalizeSpawnCommand,x}from'tinyexec'
@@ -107,6 +107,33 @@ export async function runInstall(options: InstallOptions): Promise<InstallResult
 returnawaitexecute(command,commandArgs,options)
 }
 
+exportinterfaceDedupeOptionsextendsOmit<InstallOptions,'dependencies'|'dev'|'workspace'>{
+/** Delete the lockfile and resolve dependencies from scratch. */
+recreateLockfile?: boolean
+}
+
+/**
+ * Dedupe a project's dependencies, or recreate its lockfile, with the same quiet
+ * output handling as {@link runInstall}.
+ */
+exportasyncfunctionrunDedupe(options: DedupeOptions): Promise<InstallResult>{
+const{ exec }=awaitdedupeDependencies({
+cwd: options.cwd,
+packageManager: options.packageManager,
+recreateLockfile: options.recreateLockfile,
+dry: true,
+})
+
+if(!exec){
+return{success: true,output: '',command: '',ignoredBuilds: []}
+}
+
+constargs=[...exec.args, ...nonInteractiveArgs(options.packageManager)]
+const[command,commandArgs]=awaitwithCorepack(exec.command,args)
+
+returnawaitexecute(command,commandArgs,options)
+}
+
 /**
  * Flags that stop a package manager from asking a question we cannot answer, or
  * from failing on something the user can act on after the fact.

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

@@ -20,8 +20,11 @@ interface NuxtProjectManifest {
 }
 }
 
-exportasyncfunctioncleanupNuxtDirs(rootDir: string,buildDir: string){
-logger.info('Cleaning up generated Nuxt files and caches...')
+/** `silent` is for callers that already report progress themselves. */
+exportasyncfunctioncleanupNuxtDirs(rootDir: string,buildDir: string,options: {silent?: boolean}={}){
+if(!options.silent){
+logger.info('Cleaning up generated Nuxt files and caches...')
+}
 
 awaitrmRecursive(
 [

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

@@ -1,11 +1,20 @@
+import{existsSync}from'node:fs'
 import{chmod,mkdtemp,writeFile}from'node:fs/promises'
 import{tmpdir}from'node:os'
 import{join}from'node:path'
 importprocessfrom'node:process'
 
 import{describe,expect,it}from'vitest'
 
-import{getIgnoredBuilds,isExecutableAvailable,nonInteractiveArgs,runInstall,takeUnreportedIgnoredBuilds}from'../../../src/utils/install'
+import{getIgnoredBuilds,isExecutableAvailable,nonInteractiveArgs,runDedupe,runInstall,takeUnreportedIgnoredBuilds}from'../../../src/utils/install'
+
+asyncfunctioncreateFakePackageManager(script: string[]=['#!/bin/sh','echo "all done"']){
+constdir=awaitmkdtemp(join(tmpdir(),'nuxt-install-test-'))
+constcommand=join(dir,'fake-package-manager')
+awaitwriteFile(command,script.join('\n'))
+awaitchmod(command,0o755)
+return{ dir, command }
+}
 
 describe('nonInteractiveArgs',()=>{
 it('should opt pnpm out of prompts and strict dep builds',()=>{
@@ -109,3 +118,46 @@ describe('runInstall', () => {
 expect(result.command).toBe('nuxt-cli-nonexistent-package-manager install')
 })
 })
+
+describe('runDedupe',()=>{
+it.skipIf(process.platform==='win32')('should dedupe without printing the package manager output',async()=>{
+const{ dir, command }=awaitcreateFakePackageManager()
+
+constlines: string[]=[]
+constresult=awaitrunDedupe({
+cwd: dir,
+packageManager: {name: 'pnpm', command },
+onOutput: line=>lines.push(line),
+})
+
+expect(result.success).toBe(true)
+expect(result.command).toBe(`${command} dedupe --config.confirm-modules-purge=false --config.strict-dep-builds=false`)
+expect(lines).toEqual(['all done'])
+})
+
+it.skipIf(process.platform==='win32')('should install after removing the lockfile when recreating it',async()=>{
+const{ dir, command }=awaitcreateFakePackageManager()
+constlockFile=join(dir,'pnpm-lock.yaml')
+awaitwriteFile(lockFile,'lockfileVersion: 9.0\n')
+
+constresult=awaitrunDedupe({
+cwd: dir,
+packageManager: {name: 'pnpm', command,lockFile: 'pnpm-lock.yaml'},
+recreateLockfile: true,
+})
+
+expect(result.success).toBe(true)
+expect(result.command).toContain(`${command} install`)
+expect(existsSync(lockFile)).toBe(false)
+})
+
+it('should report a missing package manager instead of throwing',async()=>{
+constresult=awaitrunDedupe({
+cwd: process.cwd(),
+packageManager: {name: 'npm',command: 'nuxt-cli-nonexistent-package-manager'},
+})
+
+expect(result.success).toBe(false)
+expect(result.missingPackageManager).toBe(true)
+})
+})