feat: don't use vite-node in coverage packages

Author: sheremet-va

packages/coverage-v8/package.json

@@ -73,7 +73,6 @@
     "@types/istanbul-reports": "catalog:",
     "@vitest/browser": "workspace:*",
     "pathe": "catalog:",
-    "vite-node": "workspace:*",
     "vitest": "workspace:*"
   }
 }

packages/coverage-v8/src/provider.ts

@@ -1,13 +1,12 @@
 import type { CoverageMap } from 'istanbul-lib-coverage'
 import type { ProxifiedModule } from 'magicast'
 import type { Profiler } from 'node:inspector'
-import type { EncodedSourceMap, FetchResult } from 'vite-node'
-import type { AfterSuiteRunMeta } from 'vitest'
-import type { CoverageProvider, ReportContext, ResolvedCoverageOptions, TestProject, Vitest } from 'vitest/node'
+import type { CoverageProvider, ReportContext, ResolvedCoverageOptions, TestProject, Vite, Vitest } from 'vitest/node'
 import { promises as fs } from 'node:fs'
 import { fileURLToPath } from 'node:url'
 // @ts-expect-error -- untyped
 import { mergeProcessCovs } from '@bcoe/v8-coverage'
+import { cleanUrl } from '@vitest/utils'
 import astV8ToIstanbul from 'ast-v8-to-istanbul'
 import createDebug from 'debug'
 import libCoverage from 'istanbul-lib-coverage'
@@ -18,7 +17,6 @@ import { parseModule } from 'magicast'
 import { normalize } from 'pathe'
 import { provider } from 'std-env'
 import c from 'tinyrainbow'
-import { cleanUrl } from 'vite-node/utils'
 
 import { BaseCoverageProvider } from 'vitest/coverage'
 import { parseAstAsync } from 'vitest/node'
@@ -28,7 +26,7 @@ export interface ScriptCoverageWithOffset extends Profiler.ScriptCoverage {
   startOffset: number
 }
 
-type TransformResults = Map<string, FetchResult>
+type TransformResults = Map<string, Vite.TransformResult>
 interface RawCoverage { result: ScriptCoverageWithOffset[] }
 
 const FILE_PROTOCOL = 'file://'
@@ -148,7 +146,7 @@ export class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOpt
 
   private async getCoverageMapForUncoveredFiles(testedFiles: string[]): Promise<CoverageMap> {
     const transformResults = normalizeTransformResults(
-      this.ctx.vitenode.fetchCache,
+      this.ctx.vite.environments.ssr.moduleGraph,
     )
     const transform = this.createUncoveredFileTransformer(this.ctx)
 
@@ -307,24 +305,24 @@ export class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOpt
     )
   }
 
-  private async getSources<TransformResult extends (FetchResult | Awaited<ReturnType<typeof this.ctx.vitenode.transformRequest>>)>(
+  private async getSources(
     url: string,
     transformResults: TransformResults,
-    onTransform: (filepath: string) => Promise<TransformResult>,
+    onTransform: (filepath: string) => Promise<Vite.TransformResult | undefined | null>,
     functions: Profiler.FunctionCoverage[] = [],
   ): Promise<{
     code: string
-    map?: EncodedSourceMap
+    map?: Vite.Rollup.SourceMap
   }> {
     const filePath = normalize(fileURLToPath(url))
 
-    let transformResult: FetchResult | TransformResult | undefined = transformResults.get(filePath)
+    let transformResult: Vite.TransformResult | undefined | null = transformResults.get(filePath)
 
     if (!transformResult) {
       transformResult = await onTransform(removeStartsWith(url, FILE_PROTOCOL)).catch(() => undefined)
     }
 
-    const map = transformResult?.map as EncodedSourceMap | undefined
+    const map = transformResult?.map as Vite.Rollup.SourceMap | undefined
     const code = transformResult?.code
 
     if (!code) {
@@ -357,31 +355,37 @@ export class V8CoverageProvider extends BaseCoverageProvider<ResolvedCoverageOpt
   private async convertCoverage(
     coverage: RawCoverage,
     project: TestProject = this.ctx.getRootProject(),
-    transformMode?: AfterSuiteRunMeta['transformMode'],
+    environment: string,
   ): Promise<CoverageMap> {
-    let fetchCache = project.vitenode.fetchCache
+    if (environment === '__browser__' && !project.browser) {
+      throw new Error(`Cannot access browser module graph because it was torn down.`)
+    }
+
+    const moduleGraph = environment === '__browser__'
+      ? project.browser!.vite.environments.client.moduleGraph
+      : project.vite.environments[environment]?.moduleGraph
 
-    if (transformMode) {
-      fetchCache = transformMode === 'browser' ? new Map() : project.vitenode.fetchCaches[transformMode]
+    if (!moduleGraph) {
+      throw new Error(`Module graph for environment ${environment} was not defined.`)
     }
 
-    const transformResults = normalizeTransformResults(fetchCache)
+    const transformResults = normalizeTransformResults(moduleGraph)
 
     async function onTransform(filepath: string) {
-      if (transformMode === 'browser' && project.browser) {
+      if (environment === '__browser__' && project.browser) {
         const result = await project.browser.vite.transformRequest(removeStartsWith(filepath, project.config.root))
 
         if (result) {
           return { ...result, code: `${result.code}// <inline-source-map>` }
         }
       }
-      return project.vitenode.transformRequest(filepath)
+      return project.vite.environments[environment].transformRequest(filepath)
     }
 
     const scriptCoverages = []
 
     for (const result of coverage.result) {
-      if (transformMode === 'browser') {
+      if (environment === '__browser__') {
         if (result.url.startsWith('/@fs')) {
           result.url = `${FILE_PROTOCOL}${removeStartsWith(result.url, '/@fs')}`
         }
@@ -466,15 +470,15 @@ function findLongestFunctionLength(functions: Profiler.FunctionCoverage[]) {
 }
 
 function normalizeTransformResults(
-  fetchCache: Map<string, { result: FetchResult }>,
+  moduleGraph: Vite.EnvironmentModuleGraph,
 ) {
   const normalized: TransformResults = new Map()
 
-  for (const [key, value] of fetchCache.entries()) {
+  for (const [key, value] of moduleGraph.idToModuleMap) {
     const cleanEntry = cleanUrl(key)
 
-    if (!normalized.has(cleanEntry)) {
-      normalized.set(cleanEntry, value.result)
+    if (value.transformResult && !normalized.has(cleanEntry)) {
+      normalized.set(cleanEntry, value.transformResult)
     }
   }
 

packages/utils/src/helpers.ts

@@ -46,6 +46,12 @@ export function assertTypes(
   }
 }
 
+const postfixRE = /[?#].*$/
+
+export function cleanUrl(url: string): string {
+  return url.replace(postfixRE, '')
+}
+
 export function isPrimitive(value: unknown): boolean {
   return (
     value === null || (typeof value !== 'function' && typeof value !== 'object')

packages/utils/src/index.ts

@@ -8,6 +8,7 @@ export type { LoupeOptions, StringifyOptions } from './display'
 
 export {
   assertTypes,
+  cleanUrl,
   clone,
   createDefer,
   createSimpleStackTrace,

packages/vitest/src/node/coverage.ts

@@ -42,7 +42,7 @@ interface ResolvedThreshold {
 type CoverageFiles = Map<
   NonNullable<AfterSuiteRunMeta['projectName']> | symbol,
   Record<
-    AfterSuiteRunMeta['transformMode'],
+    AfterSuiteRunMeta['environment'],
     { [TestFilenames: string]: string }
   >
 >
@@ -253,19 +253,15 @@ export class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istan
     this.pendingPromises = []
   }
 
-  onAfterSuiteRun({ coverage, transformMode, projectName, testFiles }: AfterSuiteRunMeta): void {
+  onAfterSuiteRun({ coverage, environment, projectName, testFiles }: AfterSuiteRunMeta): void {
     if (!coverage) {
       return
     }
 
-    if (transformMode !== 'web' && transformMode !== 'ssr' && transformMode !== 'browser') {
-      throw new Error(`Invalid transform mode: ${transformMode}`)
-    }
-
     let entry = this.coverageFiles.get(projectName || DEFAULT_PROJECT)
 
     if (!entry) {
-      entry = { web: {}, ssr: {}, browser: {} }
+      entry = {}
       this.coverageFiles.set(projectName || DEFAULT_PROJECT, entry)
     }
 
@@ -275,8 +271,9 @@ export class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istan
       `coverage-${uniqueId++}.json`,
     )
 
+    entry[environment] ??= {}
     // If there's a result from previous run, overwrite it
-    entry[transformMode][testFilenames] = filename
+    entry[environment][testFilenames] = filename
 
     const promise = fs.writeFile(filename, JSON.stringify(coverage), 'utf-8')
     this.pendingPromises.push(promise)
@@ -286,7 +283,7 @@ export class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istan
     /** Callback invoked with a single coverage result */
     onFileRead: (data: CoverageType) => void
     /** Callback invoked once all results of a project for specific transform mode are read */
-    onFinished: (project: Vitest['projects'][number], transformMode: AfterSuiteRunMeta['transformMode']) => Promise<void>
+    onFinished: (project: Vitest['projects'][number], environment: AfterSuiteRunMeta['environment']) => Promise<void>
     onDebug: ((...logs: any[]) => void) & { enabled: boolean }
   }): Promise<void> {
     let index = 0
@@ -296,7 +293,7 @@ export class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istan
     this.pendingPromises = []
 
     for (const [projectName, coveragePerProject] of this.coverageFiles.entries()) {
-      for (const [transformMode, coverageByTestfiles] of Object.entries(coveragePerProject) as Entries<typeof coveragePerProject>) {
+      for (const [environment, coverageByTestfiles] of Object.entries(coveragePerProject) as Entries<typeof coveragePerProject>) {
         const filenames = Object.values(coverageByTestfiles)
         const project = this.ctx.getProjectByName(projectName as string)
 
@@ -315,7 +312,7 @@ export class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istan
           )
         }
 
-        await onFinished(project, transformMode)
+        await onFinished(project, environment)
       }
     }
   }
@@ -640,31 +637,31 @@ export class BaseCoverageProvider<Options extends ResolvedCoverageOptions<'istan
       ...ctx.projects.map(project => ({
         root: project.config.root,
         isBrowserEnabled: project.isBrowserEnabled(),
-        vitenode: project.vitenode,
+        vite: project.vite,
       })),
       // Check core last as it will match all files anyway
-      { root: ctx.config.root, vitenode: ctx.vitenode, isBrowserEnabled: ctx.getRootProject().isBrowserEnabled() },
+      { root: ctx.config.root, vite: ctx.vite, isBrowserEnabled: ctx.getRootProject().isBrowserEnabled() },
     ]
 
     return async function transformFile(filename: string): Promise<TransformResult | null | undefined> {
       let lastError
 
-      for (const { root, vitenode, isBrowserEnabled } of servers) {
+      for (const { root, vite, isBrowserEnabled } of servers) {
         // On Windows root doesn't start with "/" while filenames do
         if (!filename.startsWith(root) && !filename.startsWith(`/${root}`)) {
           continue
         }
 
         if (isBrowserEnabled) {
-          const result = await vitenode.transformRequest(filename, undefined, 'web').catch(() => null)
+          const result = await vite.transformRequest(filename).catch(() => null)
 
           if (result) {
             return result
           }
         }
 
         try {
-          return await vitenode.transformRequest(filename)
+          return await vite.transformRequest(filename)
         }
         catch (error) {
           lastError = error

packages/vitest/src/types/general.ts

@@ -9,7 +9,7 @@ export type TransformMode = 'web' | 'ssr'
 export interface AfterSuiteRunMeta {
   coverage?: unknown
   testFiles: string[]
-  transformMode: TransformMode | 'browser'
+  environment: string
   projectName?: string
 }