feat: experimental server persistent caching

packages/vite/src/node/config.ts

@@ -25,6 +25,7 @@ import {
   createDebugger,
   createFilter,
   dynamicImport,
+  getCodeHash,
   isBuiltin,
   isExternalUrl,
   isObject,
@@ -64,6 +65,7 @@ import type { PackageCache } from './packages'
 import { loadEnv, resolveEnvPrefix } from './env'
 import type { ResolvedSSROptions, SSROptions } from './ssr'
 import { resolveSSROptions } from './ssr'
+import { resolvePersistentCacheOptions } from './server/persistentCache'
 
 const debug = createDebugger('vite:config')
 
@@ -292,6 +294,41 @@ export interface ExperimentalOptions {
    * @default false
    */
   hmrPartialAccept?: boolean
+  /**
+   * Enables persistent cache for the development server.
+   *
+   * @experimental
+   * @default null
+   */
+  serverPersistentCaching?: ServerPersistentCacheOptions | true
+}
+
+export interface ServerPersistentCacheOptions {
+  /**
+   * Enable or disable persistent cache.
+   */
+  enabled?: boolean
+  /**
+   * Paths to files that should be taken into account when determining whether to clear the cache.
+   * By default will use the vite config file and your package lock file (for npm, yarn or pnpm).
+   */
+  cacheVersionFromFiles?: string[]
+  /**
+   * Manual version string that should be taken into account when determining whether to clear the cache.
+   * Will be added to the hash of `cacheVersionFromFiles`.
+   */
+  cacheVersion?: string
+  /**
+   * Exclude requests from being cached.
+   */
+  exclude?: (url: string) => boolean
+}
+
+export interface ResolvedServerPersistentCacheOptions {
+  cacheDir: string
+  cacheVersionFromFiles: string[]
+  cacheVersion: string
+  exclude?: (url: string) => boolean
 }
 
 export interface LegacyOptions {
@@ -319,6 +356,7 @@ export interface InlineConfig extends UserConfig {
 export type ResolvedConfig = Readonly<
   Omit<UserConfig, 'plugins' | 'assetsInclude' | 'optimizeDeps' | 'worker'> & {
     configFile: string | undefined
+    configFileHash: string | undefined
     configFileDependencies: string[]
     inlineConfig: InlineConfig
     root: string
@@ -350,6 +388,7 @@ export type ResolvedConfig = Readonly<
     worker: ResolveWorkerOptions
     appType: AppType
     experimental: ExperimentalOptions
+    serverPersistentCache: ResolvedServerPersistentCacheOptions | null
   } & PluginHookUtils
 >
 
@@ -373,6 +412,7 @@ export async function resolveConfig(
   defaultMode = 'development'
 ): Promise<ResolvedConfig> {
   let config = inlineConfig
+  let configFileHash: string | undefined
   let configFileDependencies: string[] = []
   let mode = inlineConfig.mode || defaultMode
 
@@ -404,6 +444,7 @@ export async function resolveConfig(
     if (loadResult) {
       config = mergeConfig(loadResult.config, config)
       configFile = loadResult.path
+      configFileHash = loadResult.hash
       configFileDependencies = loadResult.dependencies
     }
   }
@@ -616,8 +657,15 @@ export async function resolveConfig(
     getSortedPluginHooks: undefined!
   }
 
+  const serverPersistentCache = resolvePersistentCacheOptions({
+    config,
+    cacheDir,
+    resolvedRoot
+  })
+
   const resolvedConfig: ResolvedConfig = {
     configFile: configFile ? normalizePath(configFile) : undefined,
+    configFileHash,
     configFileDependencies: configFileDependencies.map((name) =>
       normalizePath(path.resolve(name))
     ),
@@ -666,7 +714,8 @@ export async function resolveConfig(
       ...config.experimental
     },
     getSortedPlugins: undefined!,
-    getSortedPluginHooks: undefined!
+    getSortedPluginHooks: undefined!,
+    serverPersistentCache
   }
   const resolved: ResolvedConfig = {
     ...config,
@@ -865,6 +914,7 @@ export async function loadConfigFromFile(
   path: string
   config: UserConfig
   dependencies: string[]
+  hash: string
 } | null> {
   const start = performance.now()
   const getTime = () => `${(performance.now() - start).toFixed(2)}ms`
@@ -922,7 +972,8 @@ export async function loadConfigFromFile(
     return {
       path: normalizePath(resolvedPath),
       config,
-      dependencies: bundled.dependencies
+      dependencies: bundled.dependencies,
+      hash: getCodeHash(bundled.code)
     }
   } catch (e) {
     createLogger(logLevel).error(

packages/vite/src/node/index.ts

@@ -95,6 +95,15 @@ export type {
   TransformResult
 } from './server/transformRequest'
 export type { HmrOptions, HmrContext } from './server/hmr'
+export type {
+  PersistentCache,
+  PersistentCacheEntry,
+  PersistentSimpleCacheEntry,
+  PersistentFullCacheEntry,
+  PersistentCacheFile,
+  PersistentCacheManifest,
+  PersistentCacheResult
+} from './server/persistentCache'
 
 export type {
   HMRPayload,

packages/vite/src/node/optimizer/index.ts

@@ -25,6 +25,7 @@ import {
 } from '../utils'
 import { transformWithEsbuild } from '../plugins/esbuild'
 import { ESBUILD_MODULES_TARGET } from '../constants'
+import type { ViteDevServer } from '../index'
 import { esbuildCjsExternalPlugin, esbuildDepPlugin } from './esbuildDepPlugin'
 import { scanImports } from './scan'
 export {
@@ -450,7 +451,8 @@ export async function runOptimizeDeps(
   resolvedConfig: ResolvedConfig,
   depsInfo: Record<string, OptimizedDepInfo>,
   ssr: boolean = resolvedConfig.command === 'build' &&
-    !!resolvedConfig.build.ssr
+    !!resolvedConfig.build.ssr,
+  server?: ViteDevServer
 ): Promise<DepOptimizationResult> {
   const isBuild = resolvedConfig.command === 'build'
   const config: ResolvedConfig = {
@@ -671,6 +673,10 @@ export async function runOptimizeDeps(
   const dataPath = path.join(processingCacheDir, '_metadata.json')
   writeFile(dataPath, stringifyDepsOptimizerMetadata(metadata, depsCacheDir))
 
+  if (server?._persistentCache) {
+    await server._persistentCache.updateDepsMetadata(metadata)
+  }
+
   debug(`deps bundled in ${(performance.now() - start).toFixed(2)}ms`)
 
   return processingResult

packages/vite/src/node/optimizer/optimizer.ts

@@ -230,7 +230,12 @@ async function createDepsOptimizer(
             // run on the background, but we wait until crawling has ended
             // to decide if we send this result to the browser or we need to
             // do another optimize step
-            postScanOptimizationResult = runOptimizeDeps(config, knownDeps)
+            postScanOptimizationResult = runOptimizeDeps(
+              config,
+              knownDeps,
+              undefined,
+              server
+            )
           }
         } catch (e) {
           logger.error(e.message)
@@ -271,7 +276,7 @@ async function createDepsOptimizer(
 
     startNextDiscoveredBatch()
 
-    return await runOptimizeDeps(config, knownDeps)
+    return await runOptimizeDeps(config, knownDeps, undefined, server)
   }
 
   function prepareKnownDeps() {

packages/vite/src/node/server/index.ts

@@ -79,6 +79,8 @@ import { openBrowser } from './openBrowser'
 import type { TransformOptions, TransformResult } from './transformRequest'
 import { transformRequest } from './transformRequest'
 import { searchForWorkspaceRoot } from './searchRoot'
+import type { PersistentCache } from './persistentCache'
+import { createPersistentCache } from './persistentCache'
 
 export { searchForWorkspaceRoot } from './searchRoot'
 
@@ -301,6 +303,10 @@ export interface ViteDevServer {
    * @internal
    */
   _fsDenyGlob: Matcher
+  /**
+   * @internal
+   */
+  _persistentCache: PersistentCache | null
 }
 
 export interface ResolvedServerUrls {
@@ -452,7 +458,8 @@ export async function createServer(
     _importGlobMap: new Map(),
     _forceOptimizeOnRestart: false,
     _pendingRequests: new Map(),
-    _fsDenyGlob: picomatch(config.server.fs.deny, { matchBase: true })
+    _fsDenyGlob: picomatch(config.server.fs.deny, { matchBase: true }),
+    _persistentCache: await createPersistentCache(config)
   }
 
   server.transformIndexHtml = createDevHtmlTransformFn(server)