Cache modules for faster start time

[rluvaton]

Clear and concise description of the problem

Our tests take a long time to start because of the initial module loading/resolving/transforming.

When using watch the rest of the runs are fast.

Suggested solution

It would be great if when not using watch we could improve startup time by caching the modules map/transformed/something else so only the first run would be slow

Alternative

No response

Additional context

No response

Validations

• Follow our Code of Conduct
• Read the Contributing Guidelines.
• Read the docs.
• Check that there isn't already an issue that request the same feature to avoid creating a duplicate.

[sheremet-va]

There is really not enough information here. What do you mean by "When using watch the rest of the runs are fast."? The first run on both watch and non-watch modes is identical.

Transformation is usually not a bottleneck and can save you maybe a few seconds in a minute, Vite is fast enough.

[rluvaton]

I mean there is caching in the watch mode that it would be great if it was persisted so the run mode can take advantage of it

If I have

$ vite --watch

Duration: 8s

[Updated file]
Second run: 2s

[Updated file]
Third run: 2s

It would be great if this were the case for run as well:

$ vite --run

Duration: 8s

$ vite --run
Second run: 2s (used the cache from the first run)

$ vite --run
Third run: 2s (used the cache from the second run)

Hope this is now clearer

[sheremet-va]

In your example, do you only have a single file? watch mode only reruns affected tests, so it can be much faster.

Again, the transformation is not the main reason why it's fast. It takes more time to load all Vitest dependencies and the config file than to process a single file.

[rluvaton]

In your example, do you only have a single file? watch mode only reruns affected tests, so it can be much faster.

Yes

Again, the transformation is not the main reason why it's fast. It takes more time to load all Vitest dependencies and the config file than to process a single file.

It seems that the bottleneck in our case is importing some company package, so I don't think it's the vitest dependencies and config file

[sheremet-va]

It seems that the bottleneck in our case is importing some company package, so I don't think it's the vitest dependencies and config file

So how does caching the transformed files help here? The bottleneck is import. How long does your transform take? (Printed at the end of the run)

[rluvaton]

First run in watch:

 Test Files  1 failed (1)
      Tests  1 failed (1)
   Start at  13:32:47
   Duration  8.26s (transform 5.10s, setup 7.63s, collect 2ms, tests 4ms, environment 246ms, prepare 127ms)

Second run in watch:

 Test Files  1 failed (1)
      Tests  1 failed (1)
   Start at  13:33:04
   Duration  2.06s

Third run in watch:

 Test Files  1 failed (1)
      Tests  1 failed (1)
   Start at  13:33:19
   Duration  2.58s

[rluvaton]

When using:

debug.loadDumppedModules: true

it's 2s rather than 8s

[rluvaton]

I did the following patch locally and it improvement the setup time drastically to 200ms

it's more than possible that it contain bugs

I used patch-package to patch vite-node@1.4.0

The diff that solved my problem is provided at the bottom

This introduces a bug with invalidation that it showed file not found when it exists
Fixing it was adding the following to the config:

server: { fs: { strict: false } }

diff

diff --git a/node_modules/vite-node/dist/server.mjs b/node_modules/vite-node/dist/server.mjs
index cf859a4..6d08c0c 100644
--- a/node_modules/vite-node/dist/server.mjs
+++ b/node_modules/vite-node/dist/server.mjs
@@ -1,7 +1,7 @@
 import { performance } from 'node:perf_hooks';
-import { existsSync, promises } from 'node:fs';
+import { existsSync, promises, readFileSync, writeFileSync, mkdirSync, rmSync, statSync, createReadStream } from 'node:fs';
 import assert from 'node:assert';
-import { join, extname, dirname, resolve, relative, normalize } from 'pathe';
+import { join, extname, dirname, resolve, relative, normalize, basename } from 'pathe';
 import createDebug from 'debug';
 import { isNodeBuiltin, slash, findNearestPackageData, toArray, withTrailingSlash, normalizeModuleId, toFilePath } from './utils.mjs';
 import { KNOWN_ASSET_TYPES } from './constants.mjs';
@@ -121,14 +121,309 @@ function patchWindowsImportPath(path) {
     return path;
 }
 
-function hashCode(s) {
-  return s.split("").reduce((a, b) => {
-    a = (a << 5) - a + b.charCodeAt(0);
-    return a & a;
-  }, 0);
+
+function hashCode(s, initial = 0) {
+  return s.split("").reduce(hashReducer, initial);
+}
+
+function hashReducer(hash, char) {
+  hash = (hash << 5) - hash + char.charCodeAt(0);
+  return hash & hash;
+}
+
+async function calculateFileHash(filePath) {
+  return await createReadStream(filePath).reduce((hash, chunk) => hashCode(chunk.toString(), hash), 0);
+}
+
+
+// Key to detect the version of the mapping cache file
+const MAPPING_CACHE_VERSION_KEY = '______version______';
+// The current version of the mapping cache file
+const CURRENT_MAPPING_CACHE_VERSION = 1;
+// This handle the module caching
+class ModuleCaching {
+  // Where the cache files are stored and the mapping file is stored
+  cacheDir;
+
+  // The path to the mapping file
+  mappingFilePath;
+
+  /**
+   * This is the mapping between the original file path and the transformed file path with the hash of the original file and the last time it was compiled
+   *
+   * @type {{[originalFilePath: string]: {transformedPath: string, lastCompiled: number, hash: string}}}
+   */
+  mapping;
+
+  // Whether the mapping file has changed since the last time it was written
+  changed = false;
+
+  // Whether the caching is enabled
+  enabled = false;
+
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+    this.mappingFilePath = join(this.cacheDir, 'mapping.json');
+  }
+
+  // Enable the caching
+  enable() {
+    if (this.enabled) {
+      // Already enabled
+      return;
+    }
+
+    this.enabled = true;
+
+    this.mapping = this.ensureMappingFileExists(this.cacheDir);
+
+    // Save the mapping file on exit to avoid losing some of the cache if the process is killed
+    process.once('exit', () => {
+      this.flushMappingFileCache();
+    });
+
+    // Remove unused cache entries before start to make sure the cache doesn't grow indefinitely
+    this.removeUnused().catch(e => {
+      console.error('[VITE-NODE-PATCH] Failed to remove unused cache entries', e);
+    });
+
+    // Save the mapping file every 100ms if it has changed (every 100ms to avoid writing the file too often and to avoid blocking the process)
+    const updateMappingInterval = setInterval(() => {
+      this.flushMappingFileCache();
+    }, 100);
+
+    // Do not hold the process
+    updateMappingInterval.unref();
+  }
+
+  ensureMappingFileExists() {
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+
+    let mappingFile;
+
+    if (!existsSync(this.mappingFilePath)) {
+      mappingFile = this.initEmptyMappingCacheFile(this.mappingFilePath);
+    } else {
+      try {
+        mappingFile = JSON.parse(readFileSync(this.mappingFilePath, 'utf-8').toString());
+      } catch (e) {
+        // If we fail to parse the file start over to avoid blocking the developer
+        // the cache is nice to have but not critical
+        console.error(`[VITE-NODE-PATCH] Failed to parse mapping cache file (${this.mappingFilePath})`, e);
+
+        // Reset the mapping file
+        mappingFile = this.initEmptyMappingCacheFile(this.mappingFilePath);
+      }
+    }
+
+    // If the mapping file is outdated, reset it
+    if (mappingFile?.[MAPPING_CACHE_VERSION_KEY] !== CURRENT_MAPPING_CACHE_VERSION) {
+      console.warn(
+          `[VITE-NODE-PATCH] Old mapping cache file version detected, resetting cache file (${this.mappingFilePath})`
+      );
+
+      mappingFile = this.initEmptyMappingCacheFile(this.mappingFilePath);
+    }
+
+    return mappingFile;
+  }
+
+  async removeUnused() {
+    // Remove all files that can no longer be used so the cache doesn't grow indefinitely
+    for (const originalFilePath of Object.keys(this.mapping)) {
+      if (originalFilePath === MAPPING_CACHE_VERSION_KEY) {
+        continue;
+      }
+      try {
+        if (await this.shouldRemoveCacheEntry(originalFilePath)) {
+          await this.asyncRemoveEntry(originalFilePath);
+        }
+      } catch (e) {
+        console.error('[VITE-NODE-PATCH] Failed to remove cache entry', e);
+      }
+    }
+  }
+
+  initEmptyMappingCacheFile(mappingFilePath) {
+    const emptyMappingFile = {
+      [MAPPING_CACHE_VERSION_KEY]: CURRENT_MAPPING_CACHE_VERSION
+    };
+
+    try {
+      writeFileSync(mappingFilePath, JSON.stringify(emptyMappingFile, null, 2));
+    } catch (e) {
+      console.error('[VITE-NODE-PATCH] Failed to init mapping cache file', e);
+
+      // Mark as changed so the background timer will try to write the file again
+      this.changed = true;
+    }
+
+    return emptyMappingFile;
+  }
+
+  flushMappingFileCache() {
+    if (!this.changed) {
+      return;
+    }
+
+    this.changed = false;
+    try {
+      writeFileSync(this.mappingFilePath, JSON.stringify(this.mapping, null, 2));
+    } catch (e) {
+      console.error(`[VITE-NODE-PATCH] Failed to write mapping cache file (${this.mappingFilePath})`, e);
+
+      // Mark as true as was not able to write the file
+      this.changed = true;
+    }
+  }
+
+  async fetch(filePath, fileHash) {
+    if (!this.enabled) {
+      return undefined;
+    }
+
+    if (!this.canUseCache(filePath, fileHash)) {
+      // If was not able to use the cache, remove the entry as it has no use for us
+      await this.asyncRemoveEntry(filePath);
+
+      return undefined;
+    }
+
+    return this.mapping[filePath].transformedPath;
+  }
+
+  async save(originalFilePath, originalFileHash, transformedPath) {
+    if (!this.enabled) {
+      return;
+    }
+
+    // If already has entry but the entry does not match the current one, remove it
+    if (this.mapping[originalFilePath]) {
+      const cacheEntry = this.mapping[originalFilePath];
+
+      // Don't do anything if nothing changed
+      if (cacheEntry.transformedPath === transformedPath && cacheEntry.hash === originalFileHash) {
+        return;
+      }
+
+      await this.asyncRemoveEntry(originalFilePath);
+    }
+
+    this.changed = true;
+
+    this.mapping[originalFilePath] = {
+      transformedPath,
+      lastCompiled: Date.now(),
+      hash: originalFileHash
+    };
+  }
+
+  canUseCache(originalFilePath, originalFileHash) {
+    const cacheEntry = this.mapping[originalFilePath];
+
+    return (
+        // Cache exists
+        cacheEntry &&
+        // Not too long ago
+        !this.isCacheEntryExpired(cacheEntry) &&
+        // Not changed since last compile
+        cacheEntry.hash === originalFileHash &&
+        // Cached file exists
+        existsSync(cacheEntry.transformedPath)
+    );
+  }
+
+  async shouldRemoveCacheEntry(originalFilePath) {
+    const cacheEntry = this.mapping[originalFilePath];
+
+    return (
+        // Cache missing
+        !cacheEntry ||
+        // Too long ago
+        this.isCacheEntryExpired(cacheEntry) ||
+        // Cache file is missing
+        !(await this.doesFileExists(cacheEntry.transformedPath)) ||
+        // Original file is missing
+        !(await this.doesFileExists(originalFilePath))
+
+        // TODO - should also remove on file hash mismatch but we avoid that to avoid calculating the hash value twice
+    );
+  }
+
+  async doesFileExists(filePath) {
+    try {
+      const fileStats = await promises.stat(filePath);
+
+      return fileStats.isFile();
+    } catch (e) {
+      if (e.code === 'ENOENT') {
+        return false;
+      }
+      throw e;
+    }
+  }
+
+  isCacheEntryExpired(cacheEntry) {
+    const MONTH = 1000 * 60 * 60 * 24 * 30;
+
+    return Date.now() - cacheEntry.lastCompiled > MONTH;
+  }
+
+  async asyncRemoveEntry(filePath) {
+    if (!this.mapping[filePath]) {
+      return;
+    }
+
+    this.changed = true;
+    const transformedFile = this.mapping[filePath].transformedPath;
+
+    // If the transformed file exists, remove it as well
+    if (transformedFile) {
+      try {
+        await promises.rm(transformedFile, {
+          force: true
+        });
+      } catch (e) {
+        console.error(`[VITE-NODE-PATCH] Failed to remove cache file (${transformedFile})`, e);
+      }
+    }
+
+    this.mapping[filePath] = undefined;
+  }
+
+  removeMappingFile() {
+    if (this.enabled) {
+      throw new Error('[VITE-NODE-PATCH] Cannot remove mapping file while caching is enabled');
+    }
+
+    try {
+      const fileStats = statSync(this.mappingFilePath);
+
+      // Mapping is not a file, aborting
+      if (!fileStats.isFile()) {
+        return;
+      }
+    } catch (e) {
+      return;
+    }
+
+    try {
+      rmSync(this.mappingFilePath, {
+        force: true
+      });
+    } catch (e) {
+      console.error(`[VITE-NODE-PATCH] Failed to remove mapping file (${this.mappingFilePath})`, e);
+    }
+  }
 }
+
 class Debugger {
-  constructor(root, options) {
+  static getDumpDir(root, options) {
+    return resolve(root, options?.dumpModules === true ? '.vite-node/dump' : options?.dumpModules);
+  }
+  constructor(root, options, caching) {
     this.options = options;
     if (options.dumpModules)
       this.dumpDir = resolve(root, options.dumpModules === true ? ".vite-node/dump" : options.dumpModules);
@@ -139,10 +434,15 @@ class Debugger {
         console.info(c.gray(`[vite-node] [debug] dump modules to ${this.dumpDir}`));
     }
     this.initPromise = this.clearDump();
+    this.caching = caching;
   }
   dumpDir;
   initPromise;
   externalizeMap = /* @__PURE__ */ new Map();
+  /**
+   * @type {ModuleCaching}
+   */
+  caching;
   async clearDump() {
     if (!this.dumpDir)
       return;
@@ -150,8 +450,13 @@ class Debugger {
       await promises.rm(this.dumpDir, { recursive: true, force: true });
     await promises.mkdir(this.dumpDir, { recursive: true });
   }
-  encodeId(id) {
-    return `${id.replace(/[^\w@_-]/g, "_").replace(/_+/g, "_")}-${hashCode(id)}.js`;
+  encodeFilePath(filePath, currentHash) {
+    // Have the original file name in the cached file name to make it easier to debug
+    const originalFileName = basename(filePath, extname(filePath));
+
+    // Hash on the file path as well to avoid the same file name
+    // but with different absolute file path to have the same end file path
+    return `${originalFileName}-${hashCode(filePath)}-${currentHash}.js`;
   }
   async recordExternalize(id, path) {
     if (!this.dumpDir)
@@ -159,22 +464,38 @@ class Debugger {
     this.externalizeMap.set(id, path);
     await this.writeInfo();
   }
-  async dumpFile(id, result) {
+  async dumpFile(filePath, result, currentHash) {
     if (!result || !this.dumpDir)
       return;
     await this.initPromise;
-    const name = this.encodeId(id);
-    return await promises.writeFile(join(this.dumpDir, name), `// ${id.replace(/\0/g, "\\0")}
+    const name = this.encodeFilePath(filePath, currentHash);
+    const transformedPath = join(this.dumpDir, name);
+    await promises.writeFile(transformedPath, `// ${id.replace(/\0/g, "\\0")}
 ${result.code}`, "utf-8");
+    // Save the new cache entry
+    await this.caching.save(filePath, currentHash, transformedPath);
   }
-  async loadDump(id) {
+  async loadDump(filePath, fileHash) {
     if (!this.dumpDir)
       return null;
     await this.initPromise;
-    const name = this.encodeId(id);
-    const path = join(this.dumpDir, name);
-    if (!existsSync(path))
-      return null;
+    let transformedPath;
+
+    if (this.caching.enabled) {
+      transformedPath = await this.caching.fetch(filePath, fileHash);
+
+      if (!transformedPath) {
+        return null;
+      }
+    } else {
+      // If cache is not enabled fallback to the old way
+      const name = this.encodeFilePath(filePath, fileHash);
+      transformedPath = join(this.dumpDir, name);
+
+      if (!existsSync(transformedPath)) {
+        return null;
+      }
+    }
     const code = await promises.readFile(path, "utf-8");
     return {
       code: code.replace(/^\/\/.*?\n/, ""),
@@ -216,8 +537,18 @@ class ViteNodeServer {
         loadDumppedModules: process.env.VITE_NODE_DEBUG_DUMP === "load"
       }, options.debug ?? {});
     }
-    if (options.debug)
-      this.debugger = new Debugger(server.config.root, options.debug);
+    // Create the caching
+    this.caching = new ModuleCaching(Debugger.getDumpDir(server.config.root, options.debug));
+    if (options.debug) {
+      // Enable caching when debugging is enabled
+      this.caching.enable();
+
+      this.debugger = new Debugger(server.config.root, options.debug, this.caching);
+    } else {
+      // If debugging is not enabled, remove the mapping file so the next time it would be enabled, the hash won't be outdated
+      // Remove mapping
+      this.caching.removeMappingFile();
+    }
     (_c = options.deps).moduleDirectories ?? (_c.moduleDirectories = []);
     const envValue = process.env.VITE_NODE_DEPS_MODULE_DIRECTORIES || process.env.npm_config_VITE_NODE_DEPS_MODULE_DIRECTORIES;
     const customModuleDirectories = envValue == null ? void 0 : envValue.split(",");
@@ -249,6 +580,10 @@ class ViteNodeServer {
   fetchCache = /* @__PURE__ */ new Map();
   externalizeCache = /* @__PURE__ */ new Map();
   debugger;
+  /**
+   * @type {ModuleCaching}
+   */
+  caching;
   shouldExternalize(id) {
     return shouldExternalize(id, this.options.deps, this.externalizeCache);
   }
@@ -397,11 +732,20 @@ class ViteNodeServer {
     });
   }
   async _transformRequest(id, filepath, transformMode) {
+    let currentHash;
+
+    // If we have caching
+    if (this.caching.enabled) {
+      // If the file path is valid
+      if (filepath.startsWith('/') && !filepath.startsWith('/@vite')) {
+        currentHash = await calculateFileHash(filepath);
+      }
+    }
     var _a, _b, _c, _d;
     debugRequest(id);
     let result = null;
     if ((_a = this.options.debug) == null ? void 0 : _a.loadDumppedModules) {
-      result = await ((_b = this.debugger) == null ? void 0 : _b.loadDump(id)) ?? null;
+      result = await ((_b = this.debugger) == null ? void 0 : _b.loadDump(filepath, currentHash)) ?? null;
       if (result)
         return result;
     }
@@ -416,7 +760,7 @@ class ViteNodeServer {
     if (sourcemap === "inline" && result && !id.includes("node_modules"))
       result = await this.processTransformResult(filepath, result);
     if ((_c = this.options.debug) == null ? void 0 : _c.dumpModules)
-      await ((_d = this.debugger) == null ? void 0 : _d.dumpFile(id, result));
+      await ((_d = this.debugger) == null ? void 0 : _d.dumpFile(filepath, result, currentHash));
     return result;
   }
 }

[hi-ogawa]

@rluvaton Can you provide some (artificial) example? You mentioned in #6441 (comment)

It seems that the bottleneck in our case is importing some company package

but as sheremet-va pointed out in #6441 (comment), we normally expect an external package to not be processed through Vitest transform, so it'll just ends up with import directly on Node.

Does "some company package" mean some package inside monorepo? Or does it somehow get transformed through Vitest even though it's a genuine external package? It would be great for us to know more details on your setup.

[rluvaton]

@rluvaton Can you provide some (artificial) example? You mentioned in #6441 (comment)

It seems that the bottleneck in our case is importing some company package

but as sheremet-va pointed out in #6441 (comment), we normally expect an external package to not be processed through Vitest transform, so it'll just ends up with import directly on Node.

Does "some company package" mean some package inside monorepo? Or does it somehow get transformed through Vitest even though it's a genuine external package? It would be great for us to know more details on your setup.

yes, it is inside a monorepo, sorry for not clarifying

[hi-ogawa]

For symlinked node_modules packages (which is a common case for monorepo packages), Vitest processes them through transform pipeline. However, if your monorepo package is already pre-built and it should be simply import-ed directly (which is what's called "externalized"), then you might be able to use test.server.deps.external https://vitest.dev/config/#server-deps-external

Here is a quick example https://stackblitz.com/edit/vitest-dev-vitest-waq4yf?file=vite.config.ts

For debugging, running Vite with DEBUG=vite-node:* shows something like this:

  vite-node:client:native /home/projects/vitest-dev-vitest-waq4yf/linked-dep/index.js +6ms

When it's not externalized, it would show vite-node:server:request, vite-node:client:execute pair

  vite-node:server:request /linked-dep/index.js +21ms
  vite-node:client:execute /home/projects/vitest-dev-vitest-waq4yf/linked-dep/index.js +17ms

[rluvaton]

So unfortunately we use NX which doesn't do any of those

it links packages through tsconfig paths, and not using pre-bundled, I really want to move from them though