faster way to provide got handlers for cache

Author: sokra

lib/Cache.js

@@ -9,13 +9,23 @@ const { AsyncParallelHook, AsyncSeriesBailHook, SyncHook } = require("tapable");
 
 /** @typedef {(result: any, callback: (err?: Error) => void) => void} GotHandler */
 
+const needCalls = (times, callback) => {
+	return err => {
+		if (--times === 0) {
+			return callback(err);
+		}
+		if (err && times > 0) {
+			times = NaN;
+			return callback(err);
+		}
+	};
+};
+
 class Cache {
 	constructor() {
 		this.hooks = {
 			/** @type {AsyncSeriesBailHook<string, string>} */
-			get: new AsyncSeriesBailHook(["identifier", "etag"]),
-			/** @type {AsyncParallelHook<string, string, any>} */
-			got: new AsyncParallelHook(["identifier", "etag", "data"]),
+			get: new AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
 			/** @type {AsyncParallelHook<string, string, any>} */
 			store: new AsyncParallelHook(["identifier", "etag", "data"]),
 			/** @type {SyncHook} */
@@ -28,18 +38,24 @@ class Cache {
 	}
 
 	get(identifier, etag, callback) {
-		this.hooks.get.callAsync(identifier, etag, (err, result) => {
+		const gotHandlers = [];
+		this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, result) => {
 			if (err) {
 				callback(err);
 				return;
 			}
-			this.hooks.got.callAsync(identifier, etag, result, err => {
-				if (err) {
-					callback(err);
-					return;
+			if (gotHandlers.length > 1) {
+				const innerCallback = needCalls(gotHandlers.length, () =>
+					callback(null, result)
+				);
+				for (const gotHandler of gotHandlers) {
+					gotHandler(result, innerCallback);
 				}
+			} else if (gotHandlers.length === 1) {
+				gotHandlers[0](result, () => callback(null, result));
+			} else {
 				callback(null, result);
-			});
+			}
 		});
 	}
 

lib/cache/FileCachePlugin.js

@@ -108,7 +108,6 @@ class FileCachePlugin {
 	 */
 	constructor(options) {
 		this.options = options;
-		this.missingEntries = new Set();
 	}
 
 	/**
@@ -179,7 +178,6 @@ class FileCachePlugin {
 				});
 		}
 		const storeEntry = (identifier, etag, data) => {
-			this.missingEntries.delete(identifier);
 			const entry = {
 				identifier,
 				data: etag ? () => data : data,
@@ -227,20 +225,10 @@ class FileCachePlugin {
 			}
 		};
 		compiler.cache.hooks.store.tapPromise("FileCachePlugin", storeEntry);
-		compiler.cache.hooks.got.tapPromise(
-			"FileCachePlugin",
-			(identifier, etag, result) => {
-				if (result !== undefined && this.missingEntries.has(identifier)) {
-					return storeEntry(identifier, etag, result);
-				} else {
-					return resolvedPromise;
-				}
-			}
-		);
 
 		compiler.cache.hooks.get.tapPromise(
 			"FileCachePlugin",
-			(identifier, etag) => {
+			(identifier, etag, gotHandlers) => {
 				let logMessage;
 				let cacheEntryPromise;
 				if (store === "pack") {
@@ -252,38 +240,43 @@ class FileCachePlugin {
 					logMessage = filename;
 					cacheEntryPromise = serializer.deserializeFromFile(filename);
 				}
+				const registerGot = () => {
+					gotHandlers.push((result, callback) => {
+						if (result !== undefined) {
+							storeEntry(identifier, etag, result).then(callback, callback);
+						} else {
+							callback();
+						}
+					});
+				};
 				return cacheEntryPromise.then(
 					cacheEntry => {
 						if (cacheEntry === undefined) {
-							this.missingEntries.add(identifier);
-							return;
+							return registerGot();
 						}
 						if (cacheEntry.identifier !== identifier) {
 							if (log >= 3) {
 								console.warn(
 									`Restored ${identifier} from ${logMessage}, but identifier doesn't match.`
 								);
 							}
-							this.missingEntries.add(identifier);
-							return;
+							return registerGot();
 						}
 						if (cacheEntry.etag !== etag) {
 							if (log >= 3) {
 								console.warn(
 									`Restored ${identifier} from ${logMessage}, but etag doesn't match.`
 								);
 							}
-							this.missingEntries.add(identifier);
-							return;
+							return registerGot();
 						}
 						if (cacheEntry.version !== version) {
 							if (log >= 3) {
 								console.warn(
 									`Restored ${identifier} from ${logMessage}, but version doesn't match.`
 								);
 							}
-							this.missingEntries.add(identifier);
-							return;
+							return registerGot();
 						}
 						if (log >= 3) {
 							console.warn(`Restored ${identifier} from ${logMessage}.`);
@@ -292,14 +285,14 @@ class FileCachePlugin {
 						return cacheEntry.data;
 					},
 					err => {
-						this.missingEntries.add(identifier);
 						if (log >= 1 && err && err.code !== "ENOENT") {
 							console.warn(
 								`Restoring failed for ${identifier} from ${logMessage}: ${
 									log >= 4 ? err.stack : err
 								}`
 							);
 						}
+						registerGot();
 					}
 				);
 			}

lib/cache/MemoryCachePlugin.js

@@ -23,20 +23,21 @@ class MemoryCachePlugin {
 				cache.set(identifier, { etag, data });
 			}
 		);
-		compiler.cache.hooks.got.tap(
+		compiler.cache.hooks.get.tap(
 			"MemoryCachePlugin",
-			(identifier, etag, result) => {
-				if (result !== undefined) {
-					cache.set(identifier, { etag, data: result });
+			(identifier, etag, gotHandlers) => {
+				const cacheEntry = cache.get(identifier);
+				if (cacheEntry !== undefined && cacheEntry.etag === etag) {
+					return cacheEntry.data;
 				}
+				gotHandlers.push((result, callback) => {
+					if (result !== undefined) {
+						cache.set(identifier, { etag, data: result });
+					}
+					return callback();
+				});
 			}
 		);
-		compiler.cache.hooks.get.tap("MemoryCachePlugin", (identifier, etag) => {
-			const cacheEntry = cache.get(identifier);
-			if (cacheEntry !== undefined && cacheEntry.etag === etag) {
-				return cacheEntry.data;
-			}
-		});
 	}
 }
 module.exports = MemoryCachePlugin;