Move things into FileCache from AssetCache

Author: zachleat

src/AssetCache.js

@@ -1,13 +1,13 @@
 const fs = require("graceful-fs");
 const path = require("path");
 const { createHash } = require("crypto");
-const debugUtil = require("debug");
 const { DateCompare } = require("@11ty/eleventy-utils");
 
 const FileCache = require("./FileCache.js");
 const Sources = require("./Sources.js");
 const DirectoryManager = require("./DirectoryManager.js");
 
+const debugUtil = require("debug");
 const debug = debugUtil("Eleventy:Fetch");
 const debugAssets = debugUtil("Eleventy:Assets");
 
@@ -175,7 +175,8 @@ class AssetCache {
 	get cache() {
 		if (!this.#cache || this.#cacheLocationDirty) {
 			let cache = new FileCache(this.cacheFilename, {
-				dir: this.rootDir
+				dir: this.rootDir,
+				source: this.source,
 			});
 			cache.setDryRun(this.options.dryRun);
 			cache.setDirectoryManager(this.#directoryManager);
@@ -190,16 +191,6 @@ class AssetCache {
 		return DateCompare.getDurationMs(duration);
 	}
 
-	getCachedContentsPath(type = "buffer") {
-		if(type === "xml") {
-			type = "text";
-		} else if(type === "parsed-xml") {
-			type = "json";
-		}
-
-		return `${this.cachePath}.${type}`;
-	}
-
 	setDirectoryManager(manager) {
 		this.#directoryManager = manager;
 	}
@@ -222,59 +213,14 @@ class AssetCache {
 			throw new Error("save(contents) expects contents (was falsy)");
 		}
 
-		this.cache.set(this.hash, {
-			cachedAt: Date.now(),
-			type: type,
-			metadata,
-		});
-
-		let contentPath = this.getCachedContentsPath(type);
-
-		if (type === "json" || type === "parsed-xml") {
-			contents = JSON.stringify(contents);
-		}
-
-		this.#rawContents[type] = contents;
-
-		if(this.options.dryRun) {
-			debug(`Dry run writing ${contentPath}`);
-			return;
-		}
-
-		this.ensureDir();
+		this.cache.set(type, contents, metadata);
 
-		debugAssets("[11ty/eleventy-fetch] Writing %o from %o", contentPath, this.source);
-
-		// the contents must exist before the cache metadata are saved below
-		fs.writeFileSync(contentPath, contents);
-		debug(`Writing ${contentPath}`);
-	}
-
-	async #getCachedContents(type) {
-		let contentPath = this.getCachedContentsPath(type);
-
-		debug(`Fetching from cache ${contentPath}`);
-
-		if(this.source) {
-			debugAssets("[11ty/eleventy-fetch] Reading via %o", this.source);
-		} else {
-			debugAssets("[11ty/eleventy-fetch] Reading %o", contentPath);
-		}
-
-		if (type === "json" || type === "parsed-xml") {
-			return require(contentPath);
-		}
-
-		return fs.readFileSync(contentPath, type !== "buffer" ? "utf8" : null);
+		// Dry-run handled downstream
+		this.#cache.save();
 	}
 
-	async getCachedContents(type) {
-		if(!this.#rawContents[type]) {
-			this.#rawContents[type] = this.#getCachedContents(type);
-		}
-
-		// already saved on this instance in-memory
-		return this.#rawContents[type];
+	getCachedContents() {
+		return this.#cache.getContents();
 	}
 
 	_backwardsCompatibilityGetCachedValue(type) {
@@ -288,23 +234,23 @@ class AssetCache {
 		return Buffer.from(this.cachedObject.contents);
 	}
 
-	async getCachedValue() {
+	getCachedValue() {
 		let type = this.cachedObject.type;
 
 		// backwards compat with old caches
+		// v6+ caches use `data` as internal property for contents
 		if (this.cachedObject.contents) {
 			return this._backwardsCompatibilityGetCachedValue(type);
 		}
 
 		if(this.options.returnType === "response") {
 			return {
 				...this.cachedObject.metadata?.response,
-				body: await this.getCachedContents(type),
+				body: this.getCachedContents(type),
 				cache: "hit",
 			}
 		}
 
-		// promise
 		return this.getCachedContents(type);
 	}
 
@@ -313,7 +259,7 @@ class AssetCache {
 	}
 
 	isCacheValid(duration = this.duration) {
-		if (!this.cachedObject) {
+		if (!this.cachedObject || !this.cachedObject.cachedAt) {
 			// not cached
 			return false;
 		}
@@ -322,7 +268,7 @@ class AssetCache {
 	}
 
 	get cachedObject() {
-		return this.cache.get(this.hash);
+		return this.cache.get();
 	}
 
 	// Deprecated
@@ -345,17 +291,18 @@ class AssetCache {
 	}
 
 	// for testing
-	hasCacheFiles() {
-		return fs.existsSync(this.cachePath) || fs.existsSync(this.getCachedContentsPath());
+	hasAnyCacheFiles() {
+		for(let p of this.#cache.getFilePaths()) {
+			if(fs.existsSync(p)) {
+				return true;
+			}
+		}
+		return false;
 	}
 
 	// for testing
 	async destroy() {
-		let paths = [];
-		paths.push(this.cachePath);
-		paths.push(this.getCachedContentsPath("json"));
-		paths.push(this.getCachedContentsPath("text"));
-		paths.push(this.getCachedContentsPath("buffer"));
+		let paths = this.#cache.getFilePaths();
 
 		await Promise.all(paths.map(path => {
 			if (fs.existsSync(path)) {

src/DirectoryManager.js

@@ -1,5 +1,5 @@
 const fs = require("node:fs");
-const debug = require("debug")("Eleventy:Assets");
+const debugAssets = require("debug")("Eleventy:Assets");
 
 class DirectoryManager {
   #dirs = new Set();
@@ -14,7 +14,7 @@ class DirectoryManager {
     }
 
     this.#dirs.add(dir);
-    debug("Creating directory %o", dir);
+    debugAssets("Creating directory %o", dir);
     fs.mkdirSync(dir, { recursive: true });
   }
 }

src/FileCache.js

@@ -1,26 +1,35 @@
 const fs = require("node:fs");
 const path = require("node:path");
+const debugUtil = require("debug");
+const debug = debugUtil("Eleventy:Fetch");
+const debugAssets = debugUtil("Eleventy:Assets");
 
 const DirectoryManager = require("./DirectoryManager.js");
 const ExistsCache = require("./ExistsCache.js");
 
 let existsCache = new ExistsCache();
 
 class FileCache {
+	#source;
 	#directoryManager;
-	#data = {};
+	#metadata;
+	#contents;
 	#dryRun = false;
 	#cacheDirectory = ".cache";
+	#savePending = false;
 	#counts = {
 		read: 0,
 		write: 0,
-	}
+	};
 
-	constructor(cacheId, options = {}) {
-		this.cacheId = cacheId;
+	constructor(cacheFilename, options = {}) {
+		this.cacheFilename = cacheFilename;
 		if(options.dir) {
 			this.#cacheDirectory = options.dir;
 		}
+		if(options.source) {
+			this.#source = options.source;
+		}
 	}
 
 	setDryRun(val) {
@@ -44,39 +53,118 @@ class FileCache {
 		this.#directoryManager.create(this.#cacheDirectory);
 	}
 
-	set(id, obj) {
-		if(this.#data[id] !== obj) {
-			this.#data[id] = obj;
-			this.save();
-		}
+	isSideLoaded() {
+		return this.#metadata?.type === "buffer";
+	}
+
+	set(type, contents, extraMetadata = {}) {
+		this.#savePending = true;
+
+		this.#metadata = {
+			cachedAt: Date.now(),
+			type,
+			// source: this.#source,
+			metadata: extraMetadata,
+		};
+
+		this.#contents = contents;
 	}
 
 	get fsPath() {
-		return path.join(this.#cacheDirectory, this.cacheId);
+		return path.join(this.#cacheDirectory, this.cacheFilename);
+	}
+
+	// only when side loaded (buffer content)
+	get contentsPath() {
+		return `${this.fsPath}.buffer`;
 	}
 
-	get(id) {
-		if(this.#data[id]) {
-			return this.#data[id];
+	get() {
+		if(this.#metadata) {
+			return this.#metadata;
 		}
 
 		if(!existsCache.exists(this.fsPath)) {
 			return;
 		}
 
-		this.#counts.read++;
+		debug(`Fetching from cache ${this.contentsPath}`);
+		if(this.#source) {
+			debugAssets("[11ty/eleventy-fetch] Reading via %o", this.#source);
+		} else {
+			debugAssets("[11ty/eleventy-fetch] Reading %o", this.contentsPath);
+		}
 
+		this.#counts.read++;
 		let data = fs.readFileSync(this.fsPath, "utf8");
 		let json = JSON.parse(data);
-		this.#data[id] = json;
+		this.#metadata = json;
+
+		if(json.data) { // not side-loaded
+			this.#contents = json.data;
+		}
+
 		return json;
 	}
 
+	getContents() {
+		if(this.#contents) {
+			return this.#contents;
+		}
+		// Side loaded contents are embedded inside, but we check (for backwards compat)
+		if(!this.isSideLoaded() && this.get()?.data) {
+			return this.get()?.data;
+		}
+
+		if(!existsCache.exists(this.contentsPath)) {
+			return;
+		}
+
+		debug(`Fetching from cache ${this.contentsPath}`);
+		if(this.#source) {
+			debugAssets("[11ty/eleventy-fetch] Reading (side loaded) via %o", this.#source);
+		} else {
+			debugAssets("[11ty/eleventy-fetch] Reading (side loaded) %o", this.contentsPath);
+		}
+
+		this.#counts.read++;
+		let data = fs.readFileSync(this.contentsPath, null);
+		this.#contents = data;
+		return data;
+	}
+
 	save() {
+		if(this.#dryRun || !this.#savePending || this.#metadata && Object.keys(this.#metadata) === 0) {
+			return;
+		}
+
 		this.ensureDir(); // doesn’t add to counts (yet?)
 
+		// contents before metadata
+		if(this.isSideLoaded()) {
+			debugAssets("[11ty/eleventy-fetch] Writing %o (side loaded) from %o", this.contentsPath, this.#source);
+
+			this.#counts.write++;
+
+			// the contents must exist before the cache metadata are saved below
+			fs.writeFileSync(this.contentsPath, contents);
+			debug(`Writing ${this.contentsPath}`);
+		}
+
 		this.#counts.write++;
-		fs.writeFileSync(this.fsPath, JSON.stringify(this.#data), "utf8");
+		debugAssets("[11ty/eleventy-fetch] Writing %o from %o", this.fsPath, this.#source);
+		fs.writeFileSync(this.fsPath, JSON.stringify(Object.assign({}, this.#metadata, { data: this.#contents })), "utf8");
+		debug(`Writing ${this.fsPath}`);
+	}
+
+	// for testing
+	getFilePaths() {
+		let paths = new Set();
+		paths.add(this.fsPath);
+		if(this.isSideLoaded()) {
+			paths.add(this.contentsPath);
+		}
+		return Array.from(paths);
 	}
 }