feat: persistent cache plugin

packages/plugin-persistent-cache/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-present, Yuxi (Evan) You and Vite contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

packages/plugin-persistent-cache/README.md

@@ -0,0 +1,18 @@
+# @vitejs/plugin-persistent-cache [![npm](https://img.shields.io/npm/v/@vitejs/plugin-persistent-cache.svg)](https://npmjs.com/package/@vitejs/plugin-persistent-cache)
+
+## Usage
+
+```js
+// vite.config.js
+import cache from '@vitejs/plugin-persistent-cache'
+
+export default {
+  plugins: [
+    cache({
+      // Options
+    }),
+  ],
+}
+```
+
+## Options

packages/plugin-persistent-cache/build.config.ts

@@ -0,0 +1,14 @@
+import { defineBuildConfig } from 'unbuild'
+
+export default defineBuildConfig({
+  entries: ['src/index'],
+  clean: true,
+  declaration: true,
+  rollup: {
+    emitCJS: true,
+    inlineDependencies: true,
+    esbuild: {
+      target: 'node18',
+    },
+  },
+})

packages/plugin-persistent-cache/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@vitejs/plugin-persistent-cache",
+  "version": "4.1.1",
+  "license": "MIT",
+  "author": "Guillaume Chau",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "frontend",
+    "vite",
+    "vite-plugin",
+    "cache"
+  ],
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "dev": "unbuild --stub",
+    "build": "unbuild && pnpm run patch-cjs",
+    "patch-cjs": "tsx ../../scripts/patchCJS.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": "^18.0.0 || >=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitejs/vite.git",
+    "directory": "packages/plugin-persistent-cache"
+  },
+  "bugs": {
+    "url": "https://github.com/vitejs/vite/issues"
+  },
+  "homepage": "https://github.com/vitejs/vite/tree/main/packages/plugin-persistent-cache#readme",
+  "funding": "https://github.com/vitejs/vite?sponsor=1",
+  "dependencies": {},
+  "peerDependencies": {
+    "vite": "^4.0.0"
+  },
+  "devDependencies": {
+    "debug": "^4.3.4",
+    "picocolors": "^1.0.0",
+    "vite": "workspace:*"
+  }
+}

packages/plugin-persistent-cache/src/cache-version.ts

@@ -0,0 +1,43 @@
+import fs from 'node:fs'
+import { type ResolvedConfig, version } from 'vite'
+import type { ResolvedOptions } from './types.js'
+import { getCodeHash } from './utils.js'
+
+export async function computeCacheVersion(
+  options: ResolvedOptions,
+  config: ResolvedConfig,
+): Promise<string> {
+  const hashedVersionFiles = await Promise.all(
+    options.cacheVersionFromFiles.map((file) => {
+      if (!fs.existsSync(file)) {
+        throw new Error(`Persistent cache version file not found: ${file}`)
+      }
+      return fs.promises.readFile(file, 'utf-8')
+    }),
+  ).then((codes) => getCodeHash(codes.join('')))
+
+  const defineHash = config.define
+    ? getCodeHash(JSON.stringify(config.define))
+    : ''
+
+  const envHash = getCodeHash(JSON.stringify(config.env))
+
+  let configFileHash: string | undefined
+  if (config.configFile) {
+    const code = fs.readFileSync(config.configFile, 'utf-8')
+    configFileHash = getCodeHash(code)
+  }
+
+  const cacheVersion = [
+    options.cacheVersion,
+    `vite:${version}`,
+    configFileHash,
+    hashedVersionFiles,
+    defineHash,
+    envHash,
+  ]
+    .filter(Boolean)
+    .join('-')
+
+  return cacheVersion
+}

packages/plugin-persistent-cache/src/const.ts

@@ -0,0 +1 @@
+export const DEP_VERSION_RE = /[?&](v=[\w.-]+)\b/

packages/plugin-persistent-cache/src/debug.ts

@@ -0,0 +1,3 @@
+import debug from 'debug'
+
+export const debugLog = debug('vite:persistent-cache')

packages/plugin-persistent-cache/src/deps.ts

@@ -0,0 +1,66 @@
+import fs from 'node:fs'
+import type { DepOptimizationMetadata } from 'vite'
+import type { CacheManifest, DepsMetadataManager } from './types.js'
+import { debugLog } from './debug.js'
+
+interface UseDepsMetadataOptions {
+  manifest: CacheManifest
+  patchedDuringCurrentSession: Set<string>
+}
+
+export function useDepsMetadata({
+  manifest,
+  patchedDuringCurrentSession,
+}: UseDepsMetadataOptions): DepsMetadataManager {
+  // Optimized deps
+
+  let depsMetadata: DepOptimizationMetadata | null = null
+
+  async function updateDepsMetadata(metadata: DepOptimizationMetadata) {
+    depsMetadata = metadata
+
+    // Update existing cache files
+    await Promise.all(
+      Object.keys(manifest.modules).map(async (key) => {
+        const entry = manifest.modules[key]
+        if (entry?.fullData) {
+          // Gather code changes
+          const optimizedDeps: [string, string][] = []
+          for (const m of entry.fullData.importedModules) {
+            for (const depId in metadata.optimized) {
+              const dep = metadata.optimized[depId]
+              if (dep.file === m.file) {
+                optimizedDeps.push([
+                  m.url,
+                  m.url.replace(/v=\w+/, `v=${metadata.browserHash}`),
+                ])
+                break
+              }
+            }
+          }
+          // Apply code changes
+          if (optimizedDeps.length) {
+            let code = await fs.promises.readFile(entry.fileCode, 'utf8')
+            patchedDuringCurrentSession.add(key)
+            for (const [from, to] of optimizedDeps) {
+              code = code.replaceAll(from, to)
+            }
+            await fs.promises.writeFile(entry.fileCode, code, 'utf8')
+            debugLog(
+              `Updated ${
+                entry.id
+              } with new optimized deps imports: ${optimizedDeps
+                .map(([from, to]) => `${from} -> ${to}`)
+                .join(', ')}`,
+            )
+          }
+        }
+      }),
+    )
+  }
+
+  return {
+    getDepsMetadata: () => depsMetadata,
+    updateDepsMetadata,
+  }
+}

packages/plugin-persistent-cache/src/index.ts

@@ -0,0 +1,151 @@
+import type { CacheTransformReadResult, Plugin } from 'vite'
+import type {
+  DepsMetadataManager,
+  ManifestManager,
+  Options,
+  ResolvedOptions,
+} from './types'
+import { resolveOptions } from './options.js'
+import { computeCacheVersion } from './cache-version.js'
+import { useCacheManifest } from './manifest.js'
+import { getCodeHash } from './utils.js'
+import { DEP_VERSION_RE } from './const.js'
+import { read } from './read.js'
+import { write } from './write.js'
+import { useDepsMetadata } from './deps.js'
+
+function vitePersistentCachePlugin(pluginOptions: Options = {}): Plugin {
+  let resolvedOptions: ResolvedOptions
+  let cacheVersion: string
+  let manifestManager: ManifestManager
+  let depsMetadataManager: DepsMetadataManager
+
+  /**
+   * This is used to skip read for modules that were patched by the cache for future warm restarts
+   * in case the same module is red from persistent cache again during the same session.
+   * For example: rewriting optimized deps imports should be "reverted" for the current session
+   * as they will be incorrect otherwise (vite keeps the version query stable until next restart).
+   */
+  const patchedDuringCurrentSession = new Set<string>()
+
+  return {
+    name: 'vite:persistent-cache',
+    apply: 'serve',
+
+    async configResolved(config) {
+      resolvedOptions = resolveOptions({
+        pluginOptions,
+        cacheDir: config.cacheDir,
+        root: config.root,
+      })
+
+      cacheVersion = await computeCacheVersion(resolvedOptions, config)
+
+      manifestManager = await useCacheManifest(
+        resolvedOptions.cacheDir,
+        cacheVersion,
+      )
+
+      depsMetadataManager = useDepsMetadata({
+        manifest: manifestManager.manifest,
+        patchedDuringCurrentSession,
+      })
+    },
+
+    serveLoadCacheGetKey(id, { file, url, ssr }) {
+      const isIncluded =
+        !file.includes(resolvedOptions.cacheDir) &&
+        // Don't cache vite client
+        !file.includes('vite/dist/client') &&
+        (!resolvedOptions?.exclude || !resolvedOptions.exclude(url))
+
+      if (isIncluded) {
+        return getCodeHash(id.replace(DEP_VERSION_RE, '')) + (ssr ? '-ssr' : '')
+      }
+
+      return null
+    },
+
+    async serveLoadCacheRead(cacheKey, options) {
+      return read({
+        key: cacheKey,
+        manifest: manifestManager.manifest,
+        patchedDuringCurrentSession,
+      })
+    },
+
+    async serveLoadCacheWrite(data) {
+      await write({
+        data,
+        resolvedOptions,
+        manifestManager,
+        depsMetadataManager,
+        patchedDuringCurrentSession,
+      })
+      manifestManager.queueManifestWrite()
+    },
+
+    serveTransformCacheGetKey(id, { code, ssr }) {
+      const isIncluded =
+        // Exclude glob matching so it's always re-evaluated
+        !code.includes('import.meta.glob')
+
+      if (isIncluded) {
+        return getCodeHash(id + code) + (ssr ? '-ssr' : '')
+      }
+
+      return null
+    },
+
+    async serveTransformCacheRead(cacheKey, options) {
+      const cached = await read({
+        key: cacheKey,
+        manifest: manifestManager.manifest,
+        patchedDuringCurrentSession,
+      })
+      if (cached) {
+        let result: CacheTransformReadResult = {
+          code: cached.code,
+          map: cached.map,
+        }
+
+        // Restore module graph node info for HMR
+        const entry = manifestManager.manifest.modules[cacheKey]
+        if (entry?.fullData) {
+          const importedBindings = new Map<string, Set<string>>()
+          for (const [key, value] of Object.entries(
+            entry.fullData.importedBindings,
+          )) {
+            importedBindings.set(key, new Set(value))
+          }
+
+          result = {
+            ...result,
+            importedModules: new Set(
+              entry.fullData.importedModules.map(({ url }) => url),
+            ),
+            importedBindings,
+            acceptedModules: new Set(entry.fullData.acceptedHmrDeps),
+            acceptedExports: new Set(entry.fullData.acceptedHmrExports),
+            isSelfAccepting: entry.fullData.isSelfAccepting,
+          }
+        }
+
+        return result
+      }
+      return null
+    },
+
+    async serveTransformCacheWrite(data) {
+      await write({
+        data,
+        resolvedOptions,
+        manifestManager,
+        depsMetadataManager,
+        patchedDuringCurrentSession,
+      })
+    },
+  }
+}
+
+export default vitePersistentCachePlugin