fix(vite-node): circular import stuck

examples/mocks/src/main.js

@@ -1,5 +1,10 @@
 import { funcA } from './A'
+import { funcB } from './B'
 
 export function main() {
   return funcA()
 }
+
+export function mainB() {
+  return funcB()
+}

examples/mocks/test/circular.spec.ts

@@ -1,18 +1,27 @@
 import { expect, test, vi } from 'vitest'
-import { main } from '../src/main.js'
+import { main, mainB } from '../src/main.js'
 import x from '../src/export-default-circle-index'
 
 vi.mock('../src/A', async () => ({
   ...(await vi.importActual<any>('../src/A')),
   funcA: () => 'mockedA',
 }))
 
+vi.mock('../src/B', async () => ({
+  ...(await vi.importActual<any>('../src/B')),
+  funcB: () => 'mockedB',
+}))
+
 vi.mock('../src/export-default-circle-b')
 
 test('can import actual inside mock factory', () => {
   expect(main()).toBe('mockedA')
 })
 
+test('can import in top level and inside mock factory', () => {
+  expect(mainB()).toBe('mockedB')
+})
+
 test('can mock a circular dependency', () => {
   expect(x()).toBe(undefined)
 })

packages/vite-node/src/client.ts

@@ -61,23 +61,23 @@ export class ModuleCacheMap extends Map<string, ModuleCache> {
   update(fsPath: string, mod: Partial<ModuleCache>) {
     fsPath = this.normalizePath(fsPath)
     if (!super.has(fsPath))
-      super.set(fsPath, mod)
+      this.setByModuleId(fsPath, mod)
     else
       Object.assign(super.get(fsPath) as ModuleCache, mod)
     return this
   }
 
-  setByModuleId(modulePath: string, mod: ModuleCache) {
-    return super.set(modulePath, mod)
+  setByModuleId(modulePath: string, mod: Partial<ModuleCache>) {
+    return super.set(modulePath, { imports: new Set(), importers: new Set(), ...mod })
   }
 
-  set(fsPath: string, mod: ModuleCache) {
+  set(fsPath: string, mod: Partial<ModuleCache>) {
     return this.setByModuleId(this.normalizePath(fsPath), mod)
   }
 
   getByModuleId(modulePath: string): ModuleCache {
     if (!super.has(modulePath))
-      super.set(modulePath, {})
+      this.setByModuleId(modulePath, {})
     return super.get(modulePath)!
   }
 
@@ -98,7 +98,7 @@ export class ModuleCacheMap extends Map<string, ModuleCache> {
     delete mod.resolving
     delete mod.promise
     delete mod.exports
-    mod.importers?.clear()
+    mod.importers.clear()
     return true
   }
 
@@ -129,7 +129,7 @@ export class ModuleCacheMap extends Map<string, ModuleCache> {
         continue
       invalidated.add(id)
       const subIds = Array.from(super.entries())
-        .filter(([,mod]) => mod.importers?.has(id))
+        .filter(([,mod]) => mod.importers.has(id))
         .map(([key]) => key)
       subIds.length && this.invalidateSubDepTree(subIds, invalidated)
       super.delete(id)
@@ -185,16 +185,15 @@ export class ViteNodeRunner {
     const importee = callstack[callstack.length - 1]
 
     const mod = this.moduleCache.get(fsPath)
+    const { imports, importers } = mod
 
-    if (!mod.importers)
-      mod.importers = new Set()
     if (importee)
-      mod.importers.add(importee)
+      importers.add(importee)
 
     const getStack = () => `stack:\n${[...callstack, fsPath].reverse().map(p => `  - ${p}`).join('\n')}`
 
     // check circular dependency
-    if (callstack.includes(fsPath) || callstack.some(c => this.moduleCache.get(c).importers?.has(fsPath))) {
+    if (callstack.includes(fsPath) || Array.from(imports.values()).some(i => importers.has(i))) {
       if (mod.exports)
         return mod.exports
     }
@@ -269,6 +268,10 @@ export class ViteNodeRunner {
 
     const request = async (dep: string) => {
       const [id, depFsPath] = await this.resolveUrl(`${dep}`, fsPath)
+      const depMod = this.moduleCache.getByModuleId(depFsPath)
+      depMod.importers.add(moduleId)
+      mod.imports.add(depFsPath)
+
       return this.dependencyRequest(id, depFsPath, callstack)
     }
 

packages/vite-node/src/types.ts

@@ -65,7 +65,8 @@ export interface ModuleCache {
   /**
    * Module ids that imports this module
    */
-  importers?: Set<string>
+  importers: Set<string>
+  imports: Set<string>
 }
 
 export interface ViteNodeRunnerOptions {