fix(typecheck): avoid unnecessary preparation

Author: danielroe

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

@@ -86,7 +86,7 @@ const TYPE_CHECKERS: Record<TypeChecker, TypeCheckerBackend> = {
 configFiles: GOLAR_CONFIG_FILES,
 configNote: `Golar also requires a ${styleText('cyan','golar.config.ts')} file. One will be created automatically the first time Golar is used.`,
 resolve(cwd,{ cache =true}={}){
-constbin=resolveGolarBin(cwd)
+constbin=resolveGolarBin(cwd,cache)
 constvuePlugin=resolveModulePath('@golar/vue',{from: withNodePath(cwd),try: true, cache })
 return{
  bin,
@@ -135,20 +135,20 @@ export default defineCommand({
 return
 }
 
-const[tsConfig,typechecker]=awaitPromise.all([
+consttypechecker=awaitresolveTypeChecker(cwd,checkerArgasTypeChecker|undefined)
+if(!typechecker){
+process.exitCode=1
+return
+}
+
+const[tsConfig]=awaitPromise.all([
 readTSConfig(cwd).catch(()=>({}asTSConfig)),
-resolveTypeChecker(cwd,checkerArgasTypeChecker|undefined),
 writeTypes(cwd,ctx.args.dotenv,ctx.args.logLevelas'silent'|'info'|'verbose',{
  ...ctx.data?.overrides,
  ...(ctx.args.extends&&{extends: ctx.args.extends}),
 }),
 ])
 
-if(!typechecker){
-process.exitCode=1
-return
-}
-
 constuseProjectReferences=ctx.args.build??supportsProjectReferences(tsConfig)
 
 if(ctx.args.build===undefined&&!useProjectReferences&&hasNuxtProjectReferences(tsConfig)){
@@ -217,8 +217,8 @@ function hasCheckerConfig(checker: TypeChecker, cwd: string) {
 returnTYPE_CHECKERS[checker].configFiles?.some(file=>existsSync(resolve(cwd,file)))??false
 }
 
-functionresolveGolarBin(cwd: string): string|undefined{
-constentry=resolveModulePath('golar/unstable',{from: withNodePath(cwd),try: true})
+functionresolveGolarBin(cwd: string,cache=true): string|undefined{
+constentry=resolveModulePath('golar/unstable',{from: withNodePath(cwd),try: true, cache})
 if(!entry){
 returnundefined
 }
@@ -301,8 +301,8 @@ async function promptTypeCheckerInstall(cwd: string, preferred?: TypeChecker): P
 }
 
 constresolved=TYPE_CHECKERS[selected].resolve(cwd,{cache: false})
-if(!resolved.bin){
-logger.error(`Failed to resolve ${styleText('cyan',selected)} after installation. Please check your installation.`)
+if(!resolved.bin||resolved.missing.length>0){
+logger.error(`Failed to resolve ${styleText('cyan',resolved.missing.join(' and ')||selected)} after installation. Please check your installation.`)
 return
 }
 
@@ -378,7 +378,11 @@ async function writeTypes(cwd: string, dotenv?: string, logLevel?: 'silent' | 'i
 },
 })
 
-awaitwriteTypes(nuxt)
-awaitbuildNuxt(nuxt)
-awaitnuxt.close()
+try{
+awaitwriteTypes(nuxt)
+awaitbuildNuxt(nuxt)
+}
+finally{
+awaitnuxt.close()
+}
 }

packages/nuxt-cli/test/unit/commands/typecheck.spec.ts

@@ -5,20 +5,27 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import{runCommand}from'../../../src/run'
 import{logger}from'../../../src/utils/logger'
 
-const{ x, loadKit }=vi.hoisted(()=>({
-x: vi.fn((_bin: string,_args: string[])=>Promise.resolve({exitCode: 0})),
-loadKit: vi.fn(()=>Promise.resolve({
-loadNuxt: ()=>Promise.resolve({close: ()=>Promise.resolve()}),
-buildNuxt: ()=>Promise.resolve(),
-writeTypes: ()=>Promise.resolve(),
-})),
-}))
+const{ buildNuxt, closeNuxt, loadKit, resolveModulePath, writeTypes, x }=vi.hoisted(()=>{
+constbuildNuxt=vi.fn(()=>Promise.resolve())
+constcloseNuxt=vi.fn(()=>Promise.resolve())
+constwriteTypes=vi.fn(()=>Promise.resolve())
+return{
+ buildNuxt,
+ closeNuxt,
+ writeTypes,
+x: vi.fn((_bin: string,_args: string[])=>Promise.resolve({exitCode: 0})),
+loadKit: vi.fn(()=>Promise.resolve({
+loadNuxt: ()=>Promise.resolve({close: closeNuxt}),
+ buildNuxt,
+ writeTypes,
+})),
+resolveModulePath: vi.fn((id: string): string|undefined=>id.includes('vue-tsc') ? '/node_modules/vue-tsc/bin/vue-tsc.js' : '/node_modules/typescript/index.js'),
+}
+})
 
 vi.mock('tinyexec',()=>({ x }))
 vi.mock('../../../src/utils/kit',()=>({ loadKit }))
-vi.mock('exsolve',()=>({
-resolveModulePath: (id: string)=>id.includes('vue-tsc') ? '/node_modules/vue-tsc/bin/vue-tsc.js' : '/node_modules/typescript/index.js',
-}))
+vi.mock('exsolve',()=>({ resolveModulePath }))
 
 functionfixture(name: string){
 returnfileURLToPath(newURL(`../../fixtures/typecheck/${name}`,import.meta.url))
@@ -32,6 +39,9 @@ async function run(cwd: string, ...args: string[]) {
 describe('nuxt typecheck command',()=>{
 beforeEach(()=>{
 vi.clearAllMocks()
+process.exitCode=undefined
+resolveModulePath.mockImplementation((id: string)=>id.includes('vue-tsc') ? '/node_modules/vue-tsc/bin/vue-tsc.js' : '/node_modules/typescript/index.js')
+x.mockResolvedValue({exitCode: 0})
 })
 
 it('should use build mode for Nuxt project references',async()=>{
@@ -56,4 +66,29 @@ describe('nuxt typecheck command', () => {
 expect(warn).toHaveBeenCalledWith(expect.stringContaining('"files": []'))
 warn.mockRestore()
 })
+
+it('should not prepare Nuxt when the requested checker is unavailable',async()=>{
+resolveModulePath.mockReturnValue(undefined)
+
+awaitrun(fixture('nuxt-references'),'--checker','vue-tsc')
+
+expect(process.exitCode).toBe(1)
+expect(loadKit).not.toHaveBeenCalled()
+})
+
+it('should close Nuxt when preparing types fails',async()=>{
+writeTypes.mockRejectedValueOnce(newError('could not write types'))
+
+awaitexpect(run(fixture('nuxt-references'))).rejects.toThrow('could not write types')
+expect(buildNuxt).not.toHaveBeenCalled()
+expect(closeNuxt).toHaveBeenCalledOnce()
+})
+
+it('should propagate the checker exit code',async()=>{
+x.mockResolvedValueOnce({exitCode: 2})
+
+awaitrun(fixture('nuxt-references'))
+
+expect(process.exitCode).toBe(2)
+})
 })