Refresh cache before writing contents to bundle

packages/core/cache/src/FSCache.js

@@ -116,6 +116,10 @@ export class FSCache implements Cache {
       logger.error(err, '@parcel/cache');
     }
   }
+
+  refresh(): void {
+    // NOOP
+  }
 }
 
 registerSerializableClass(`${packageJson.version}:FSCache`, FSCache);

packages/core/cache/src/IDBCache.browser.js

@@ -117,6 +117,10 @@ export class IDBCache implements Cache {
   setLargeBlob(key: string, contents: Buffer | string): Promise<void> {
     return this.setBlob(key, contents);
   }
+
+  refresh(): void {
+    // NOOP
+  }
 }
 
 registerSerializableClass(`${packageJson.version}:IDBCache`, IDBCache);

packages/core/cache/src/LMDBCache.js

@@ -102,6 +102,13 @@ export class LMDBCache implements Cache {
   async setLargeBlob(key: string, contents: Buffer | string): Promise<void> {
     await this.fs.writeFile(path.join(this.dir, key), contents);
   }
+  refresh(): void {
+    // Reset the read transaction for the store. This guarantees that
+    // the next read will see the latest changes to the store.
+    // Useful in scenarios where reads and writes are multi-threaded.
+    // See https://github.com/kriszyp/lmdb-js#resetreadtxn-void
+    this.store.resetReadTxn();
+  }
 }
 
 registerSerializableClass(`${packageJson.version}:LMDBCache`, LMDBCache);

packages/core/cache/src/types.js

@@ -14,4 +14,5 @@ export interface Cache {
   getLargeBlob(key: string): Promise<Buffer>;
   setLargeBlob(key: string, contents: Buffer | string): Promise<void>;
   getBuffer(key: string): Promise<?Buffer>;
+  refresh(): void;
 }

packages/core/core/src/requests/WriteBundlesRequest.js

@@ -101,6 +101,18 @@ async function run({input, api, farm, options}) {
 
         let info = await api.runRequest(request);
 
+        if (!useMainThread) {
+          // Force a refresh of the cache to avoid a race condition
+          // between threaded reads and writes that can result in an LMDB cache miss:
+          //   1. The main thread has read some value from cache, necessitating a read transaction.
+          //   2. Concurrently, Thread A finishes a packaging request.
+          //   3. Subsequently, the main thread is tasked with this request, but fails because the read transaction is stale.
+          // This only occurs if the reading thread has a transaction that was created before the writing thread committed,
+          // and the transaction is still live when the reading thread attempts to get the written value.
+          // See https://github.com/parcel-bundler/parcel/issues/9121
+          options.cache.refresh();
+        }
+
         bundleInfoMap[bundle.id] = info;
         if (!info.hashReferences.length) {
           hashRefToNameHash.set(