@atlaspack/cache 2.13.3-dev.144 → 2.13.3-dev.146

package/CHANGELOG.md

@@ -1,5 +1,114 @@
 # @atlaspack/cache
 
+## 3.2.5
+
+### Patch Changes
+
+- Updated dependencies [[`0999fb7`](https://github.com/atlassian-labs/atlaspack/commit/0999fb78da519a6c7582d212883e515fcf6c1252), [`35fdd4b`](https://github.com/atlassian-labs/atlaspack/commit/35fdd4b52da0af20f74667f7b8adfb2f90279b7c), [`6dd4ccb`](https://github.com/atlassian-labs/atlaspack/commit/6dd4ccb753541de32322d881f973d571dd57e4ca)]:
+  - @atlaspack/fs@2.15.5
+  - @atlaspack/rust@3.3.5
+  - @atlaspack/logger@2.14.10
+  - @atlaspack/utils@2.14.10
+
+## 3.2.4
+
+### Patch Changes
+
+- [#583](https://github.com/atlassian-labs/atlaspack/pull/583) [`124b7ff`](https://github.com/atlassian-labs/atlaspack/commit/124b7fff44f71aac9fbad289a9a9509b3dfc9aaa) Thanks [@yamadapc](https://github.com/yamadapc)! - Fix problem where cache writes could start to fail during a V3 build
+
+- Updated dependencies [[`124b7ff`](https://github.com/atlassian-labs/atlaspack/commit/124b7fff44f71aac9fbad289a9a9509b3dfc9aaa), [`e052521`](https://github.com/atlassian-labs/atlaspack/commit/e0525210850ed1606146eb86991049cf567c5dec), [`15c6d70`](https://github.com/atlassian-labs/atlaspack/commit/15c6d7000bd89da876bc590aa75b17a619a41896), [`e4d966c`](https://github.com/atlassian-labs/atlaspack/commit/e4d966c3c9c4292c5013372ae65b10d19d4bacc6), [`209692f`](https://github.com/atlassian-labs/atlaspack/commit/209692ffb11eae103a0d65c5e1118a5aa1625818), [`42a775d`](https://github.com/atlassian-labs/atlaspack/commit/42a775de8eec638ad188f3271964170d8c04d84b), [`29c2f10`](https://github.com/atlassian-labs/atlaspack/commit/29c2f106de9679adfb5afa04e1910471dc65a427), [`f4da1e1`](https://github.com/atlassian-labs/atlaspack/commit/f4da1e120e73eeb5e8b8927f05e88f04d6148c7b), [`1ef91fc`](https://github.com/atlassian-labs/atlaspack/commit/1ef91fcc863fdd2831511937083dbbc1263b3d9d)]:
+  - @atlaspack/rust@3.3.4
+  - @atlaspack/fs@2.15.4
+  - @atlaspack/feature-flags@2.16.0
+  - @atlaspack/logger@2.14.9
+  - @atlaspack/utils@2.14.9
+
+## 3.2.3
+
+### Patch Changes
+
+- Updated dependencies [[`30f6017`](https://github.com/atlassian-labs/atlaspack/commit/30f60175ba4d272c5fc193973c63bc298584775b), [`3a3e8e7`](https://github.com/atlassian-labs/atlaspack/commit/3a3e8e7be9e2dffd7304436d792f0f595d59665a), [`1ab0a27`](https://github.com/atlassian-labs/atlaspack/commit/1ab0a275aeca40350415e2b03e7440d1dddc6228), [`b8a4ae8`](https://github.com/atlassian-labs/atlaspack/commit/b8a4ae8f83dc0a83d8b145c5f729936ce52080a3)]:
+  - @atlaspack/feature-flags@2.15.1
+  - @atlaspack/fs@2.15.3
+  - @atlaspack/rust@3.3.3
+  - @atlaspack/utils@2.14.8
+  - @atlaspack/logger@2.14.8
+
+## 3.2.2
+
+### Patch Changes
+
+- Updated dependencies [[`a1773d2`](https://github.com/atlassian-labs/atlaspack/commit/a1773d2a62d0ef7805ac7524621dcabcc1afe929), [`556d6ab`](https://github.com/atlassian-labs/atlaspack/commit/556d6ab8ede759fa7f37fcd3f4da336ef1c55e8f)]:
+  - @atlaspack/feature-flags@2.15.0
+  - @atlaspack/logger@2.14.7
+  - @atlaspack/rust@3.3.2
+  - @atlaspack/fs@2.15.2
+  - @atlaspack/utils@2.14.7
+
+## 3.2.1
+
+### Patch Changes
+
+- Updated dependencies [[`e0f5337`](https://github.com/atlassian-labs/atlaspack/commit/e0f533757bd1019dbd108a04952c87da15286e09)]:
+  - @atlaspack/feature-flags@2.14.4
+  - @atlaspack/rust@3.3.1
+  - @atlaspack/fs@2.15.1
+  - @atlaspack/utils@2.14.6
+  - @atlaspack/logger@2.14.6
+
+## 3.2.0
+
+### Minor Changes
+
+- [#531](https://github.com/atlassian-labs/atlaspack/pull/531) [`d2c50c2`](https://github.com/atlassian-labs/atlaspack/commit/d2c50c2c020888b33bb25b8690d9320c2b69e2a6) Thanks [@yamadapc](https://github.com/yamadapc)! - Add way to iterate LMDB cache keys
+
+### Patch Changes
+
+- Updated dependencies [[`11d6f16`](https://github.com/atlassian-labs/atlaspack/commit/11d6f16b6397dee2f217167e5c98b39edb63f7a7), [`e2ba0f6`](https://github.com/atlassian-labs/atlaspack/commit/e2ba0f69702656f3d1ce95ab1454e35062b13b39), [`d2c50c2`](https://github.com/atlassian-labs/atlaspack/commit/d2c50c2c020888b33bb25b8690d9320c2b69e2a6), [`46a90dc`](https://github.com/atlassian-labs/atlaspack/commit/46a90dccd019a26b222c878a92d23acc75dc67c5), [`4c17141`](https://github.com/atlassian-labs/atlaspack/commit/4c1714103dab2aa9039c488f381551d2b65d1d01)]:
+  - @atlaspack/feature-flags@2.14.3
+  - @atlaspack/rust@3.3.0
+  - @atlaspack/fs@2.15.0
+  - @atlaspack/utils@2.14.5
+  - @atlaspack/logger@2.14.5
+
+## 3.1.0
+
+### Minor Changes
+
+- [#525](https://github.com/atlassian-labs/atlaspack/pull/525) [`cb9da16`](https://github.com/atlassian-labs/atlaspack/commit/cb9da16fb2648e7f53c64df0313f60d5fb8970cc) Thanks [@yamadapc](https://github.com/yamadapc)! - Fix issues with large blob cache writes, run cache writes in a write transaction
+
+### Patch Changes
+
+- Updated dependencies [[`1a2c14c`](https://github.com/atlassian-labs/atlaspack/commit/1a2c14c3cd4587551cc12e94d0680c8b71ea12bf), [`cb9da16`](https://github.com/atlassian-labs/atlaspack/commit/cb9da16fb2648e7f53c64df0313f60d5fb8970cc)]:
+  - @atlaspack/rust@3.2.0
+  - @atlaspack/fs@2.14.4
+  - @atlaspack/logger@2.14.4
+  - @atlaspack/utils@2.14.4
+
+## 3.0.1
+
+### Patch Changes
+
+- Updated dependencies [[`f27d39e`](https://github.com/atlassian-labs/atlaspack/commit/f27d39e767b06def059944b3bc5fd50797eaea96)]:
+  - @atlaspack/rust@3.1.1
+  - @atlaspack/fs@2.14.3
+  - @atlaspack/logger@2.14.3
+  - @atlaspack/utils@2.14.3
+
+## 3.0.0
+
+### Major Changes
+
+- [#512](https://github.com/atlassian-labs/atlaspack/pull/512) [`8f4e6c1`](https://github.com/atlassian-labs/atlaspack/commit/8f4e6c1b0e7c1fd48624afda48c1dcc599f1460f) Thanks [@yamadapc](https://github.com/yamadapc)! - Remove LMDB cache back-end
+
+### Patch Changes
+
+- Updated dependencies [[`a891d65`](https://github.com/atlassian-labs/atlaspack/commit/a891d652bc4eb3d757d381adf65c5083f706effc), [`d02eab9`](https://github.com/atlassian-labs/atlaspack/commit/d02eab95eb60bf7457e0869af0b773608592c0e6), [`fb87a90`](https://github.com/atlassian-labs/atlaspack/commit/fb87a901973776b33ca4ce530e9d71669a9bd36d), [`7b9e8cf`](https://github.com/atlassian-labs/atlaspack/commit/7b9e8cf29e01a98e72e46b2b2fb74ccc514f4463)]:
+  - @atlaspack/rust@3.1.0
+  - @atlaspack/fs@2.14.2
+  - @atlaspack/utils@2.14.2
+  - @atlaspack/logger@2.14.2
+
 ## 2.13.3
 
 ### Patch Changes

package/index.d.ts

@@ -7,10 +7,6 @@ export const FSCache: {
   new (cacheDir: FilePath): Cache;
 };
 
-export const LMDBCache: {
-  new (cacheDir: FilePath): Cache;
-};
-
 export const LMDBLiteCache: {
   new (cacheDir: FilePath): Cache;
 };

package/lib/FSCache.js

@@ -25,6 +25,20 @@ function _util() {
   };
   return data;
 }
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _logger() {
   const data = _interopRequireDefault(require("@atlaspack/logger"));
   _logger = function () {
@@ -62,6 +76,10 @@ class FSCache {
     await Promise.all(dirPromises);
   }
   _getCachePath(cacheId) {
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      const cleanId = (0, _rust().hashString)(cacheId);
+      return _path().default.join(this.dir, cleanId.slice(0, 2), cleanId.slice(2));
+    }
     return _path().default.join(this.dir, cacheId.slice(0, 2), cacheId.slice(2));
   }
   getStream(key) {
@@ -91,6 +109,9 @@ class FSCache {
     }
   }
   #getFilePath(key, index) {
+    if ((0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return _path().default.join(this.dir, `${(0, _rust().hashString)(key)}-${index}`);
+    }
     return _path().default.join(this.dir, `${key}-${index}`);
   }
   async #unlinkChunks(key, index) {

package/lib/LMDBLiteCache.js

@@ -12,6 +12,13 @@ function _buildCache() {
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _rust() {
   const data = require("@atlaspack/rust");
   _rust = function () {
@@ -19,16 +26,16 @@ function _rust() {
   };
   return data;
 }
-function _stream() {
-  const data = _interopRequireDefault(require("stream"));
-  _stream = function () {
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
     return data;
   };
   return data;
 }
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
+function _ncp() {
+  const data = _interopRequireDefault(require("ncp"));
+  _ncp = function () {
     return data;
   };
   return data;
@@ -40,25 +47,48 @@ function _util() {
   };
   return data;
 }
-function _fs() {
+function _stream() {
+  const data = _interopRequireDefault(require("stream"));
+  _stream = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _fs2() {
   const data = require("@atlaspack/fs");
-  _fs = function () {
+  _fs2 = function () {
     return data;
   };
   return data;
 }
 var _package = _interopRequireDefault(require("../package.json"));
 var _FSCache = require("./FSCache");
+function _logger() {
+  const data = require("@atlaspack/logger");
+  _logger = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // $FlowFixMe
+const ncpAsync = (0, _util().promisify)(_ncp().default);
 class LmdbWrapper {
   constructor(lmdb) {
     this.lmdb = lmdb;
-
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.lmdb.close();
-    };
+  }
+  has(key) {
+    return this.lmdb.hasSync(key);
+  }
+  async delete(key) {
+    await this.lmdb.delete(key);
   }
   get(key) {
     return this.lmdb.getSync(key);
@@ -67,7 +97,19 @@ class LmdbWrapper {
     const buffer = typeof value === 'string' ? Buffer.from(value) : value;
     await this.lmdb.put(key, buffer);
   }
-  resetReadTxn() {}
+  *keys() {
+    const PAGE_SIZE = 10000000;
+    let currentKeys = this.lmdb.keysSync(0, PAGE_SIZE);
+    while (currentKeys.length > 0) {
+      for (const key of currentKeys) {
+        yield key;
+      }
+      currentKeys = this.lmdb.keysSync(currentKeys.length, PAGE_SIZE);
+    }
+  }
+  compact(targetPath) {
+    this.lmdb.compact(targetPath);
+  }
 }
 exports.LmdbWrapper = LmdbWrapper;
 function open(directory
@@ -81,9 +123,14 @@ function open(directory
 }
 const pipeline = (0, _util().promisify)(_stream().default.pipeline);
 class LMDBLiteCache {
+  /**
+   * Directory where we store raw files.
+   */
+
   constructor(cacheDir) {
-    this.fs = new (_fs().NodeFS)();
+    this.fs = new (_fs2().NodeFS)();
     this.dir = cacheDir;
+    this.cacheFilesDirectory = _path().default.join(cacheDir, 'files');
     this.fsCache = new _FSCache.FSCache(this.fs, cacheDir);
     this.store = open(cacheDir, {
       name: 'parcel-cache',
@@ -99,7 +146,10 @@ class LMDBLiteCache {
     return this.store.lmdb;
   }
   async ensure() {
-    await this.fsCache.ensure();
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      await this.fsCache.ensure();
+    }
+    await this.fs.mkdirp(this.cacheFilesDirectory);
     return Promise.resolve();
   }
   serialize() {
@@ -111,7 +161,7 @@ class LMDBLiteCache {
     return new LMDBLiteCache(cache.dir);
   }
   has(key) {
-    return Promise.resolve(this.store.get(key) != null);
+    return Promise.resolve(this.store.has(key));
   }
   get(key) {
     let data = this.store.get(key);
@@ -124,10 +174,20 @@ class LMDBLiteCache {
     await this.setBlob(key, (0, _buildCache().serialize)(value));
   }
   getStream(key) {
-    return this.fs.createReadStream(_path().default.join(this.dir, key));
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return this.fs.createReadStream(_path().default.join(this.dir, key));
+    }
+    return _fs().default.createReadStream(this.getFileKey(key));
   }
-  setStream(key, stream) {
-    return pipeline(stream, this.fs.createWriteStream(_path().default.join(this.dir, key)));
+  async setStream(key, stream) {
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return pipeline(stream, this.fs.createWriteStream(_path().default.join(this.dir, key)));
+    }
+    const filePath = this.getFileKey(key);
+    await _fs().default.promises.mkdir(_path().default.dirname(filePath), {
+      recursive: true
+    });
+    return pipeline(stream, _fs().default.createWriteStream(filePath));
   }
 
   // eslint-disable-next-line require-await
@@ -147,31 +207,87 @@ class LMDBLiteCache {
   getBuffer(key) {
     return Promise.resolve(this.store.get(key));
   }
-  #getFilePath(key, index) {
-    return _path().default.join(this.dir, `${key}-${index}`);
-  }
   hasLargeBlob(key) {
-    return this.fs.exists(this.#getFilePath(key, 0));
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return this.fsCache.hasLargeBlob(key);
+    }
+    return _fs().default.promises.access(this.getFileKey(key), _fs().default.constants.F_OK).then(() => true).catch(() => false);
   }
-
-  // eslint-disable-next-line require-await
-  async getLargeBlob(key) {
-    return this.fsCache.getLargeBlob(key);
+  getLargeBlob(key) {
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return this.fsCache.getLargeBlob(key);
+    }
+    return _fs().default.promises.readFile(this.getFileKey(key));
   }
-
-  // eslint-disable-next-line require-await
   async setLargeBlob(key, contents, options) {
-    return this.fsCache.setLargeBlob(key, contents, options);
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return this.fsCache.setLargeBlob(key, contents, options);
+    }
+    const targetPath = this.getFileKey(key);
+    await _fs().default.promises.mkdir(_path().default.dirname(targetPath), {
+      recursive: true
+    });
+    return _fs().default.promises.writeFile(targetPath, contents);
   }
+
+  /**
+   * @deprecated Use store.delete instead.
+   */
   deleteLargeBlob(key) {
-    return this.fsCache.deleteLargeBlob(key);
-  }
-  refresh() {
-    // 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();
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      return this.fsCache.deleteLargeBlob(key);
+    }
+    return this.store.delete(key);
+  }
+  keys() {
+    return this.store.keys();
+  }
+  async compact(targetPath) {
+    await _fs().default.promises.mkdir(targetPath, {
+      recursive: true
+    });
+    const files = await _fs().default.promises.readdir(this.dir);
+    // copy all files except data.mdb and lock.mdb to the target path (recursive)
+    for (const file of files) {
+      const filePath = _path().default.join(this.dir, file);
+      if (file === 'data.mdb' || file === 'lock.mdb') {
+        continue;
+      }
+      await ncpAsync(filePath, _path().default.join(targetPath, file));
+    }
+    this.store.compact(_path().default.join(targetPath, 'data.mdb'));
+  }
+  refresh() {}
+
+  /**
+   * Streams, packages are stored in files instead of LMDB.
+   *
+   * On this case, if a cache key happens to have a parent traversal, ../..
+   * it is treated specially
+   *
+   * That is, something/../something and something are meant to be different
+   * keys.
+   *
+   * Plus we do not want to store values outside of the cache directory.
+   */
+  getFileKey(key) {
+    const cleanKey = key.split('/').map(part => {
+      if (part === '..') {
+        return '$$__parent_dir$$';
+      }
+      return part;
+    }).join('/');
+    return _path().default.join(this.cacheFilesDirectory, cleanKey);
+  }
+  async clear() {
+    await (0, _logger().instrumentAsync)('LMDBLiteCache::clear', async () => {
+      const keys = await this.keys();
+      for (const key of keys) {
+        await this.store.delete(key);
+      }
+      await this.fs.rimraf(this.cacheFilesDirectory);
+      await this.fs.mkdirp(this.cacheFilesDirectory);
+    });
   }
 }
 exports.LMDBLiteCache = LMDBLiteCache;

package/lib/index.js

@@ -25,17 +25,6 @@ Object.keys(_IDBCache).forEach(function (key) {
     }
   });
 });
-var _LMDBCache = require("./LMDBCache");
-Object.keys(_LMDBCache).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _LMDBCache[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _LMDBCache[key];
-    }
-  });
-});
 var _LMDBLiteCache = require("./LMDBLiteCache");
 Object.keys(_LMDBLiteCache).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaspack/cache",
   "description": "Interface for defining caches and file-system, IDB and LMDB implementations.",
-  "version": "2.13.3-dev.144+ea7d58b70",
+  "version": "2.13.3-dev.146+33cba81e9",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -23,19 +23,19 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.3-dev.144+ea7d58b70",
-    "@atlaspack/fs": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/logger": "2.14.1-dev.144+ea7d58b70",
-    "@atlaspack/rust": "3.0.1-dev.144+ea7d58b70",
-    "@atlaspack/utils": "2.14.1-dev.144+ea7d58b70",
-    "lmdb": "2.8.5"
+    "@atlaspack/build-cache": "2.13.3-dev.146+33cba81e9",
+    "@atlaspack/feature-flags": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/fs": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/logger": "2.14.1-dev.146+33cba81e9",
+    "@atlaspack/rust": "3.0.1-dev.146+33cba81e9",
+    "@atlaspack/utils": "2.14.1-dev.146+33cba81e9",
+    "ncp": "^2.0.0"
   },
   "devDependencies": {
     "idb": "^5.0.8"
   },
   "browser": {
-    "./src/IDBCache.js": "./src/IDBCache.browser.js",
-    "./src/LMDBCache.js": false
+    "./src/IDBCache.js": "./src/IDBCache.browser.js"
   },
-  "gitHead": "ea7d58b70fbe4bbc6324d4053ac673ea307b7bf6"
+  "gitHead": "33cba81e98b6eb098014f5a19d7932821b95f075"
 }

package/src/FSCache.js

@@ -9,6 +9,8 @@ import stream from 'stream';
 import path from 'path';
 import {promisify} from 'util';
 
+import {hashString} from '@atlaspack/rust';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import logger from '@atlaspack/logger';
 import {
   deserialize,
@@ -51,6 +53,10 @@ export class FSCache implements Cache {
   }
 
   _getCachePath(cacheId: string): FilePath {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      const cleanId = hashString(cacheId);
+      return path.join(this.dir, cleanId.slice(0, 2), cleanId.slice(2));
+    }
     return path.join(this.dir, cacheId.slice(0, 2), cacheId.slice(2));
   }
 
@@ -90,6 +96,9 @@ export class FSCache implements Cache {
   }
 
   #getFilePath(key: string, index: number): string {
+    if (getFeatureFlag('cachePerformanceImprovements')) {
+      return path.join(this.dir, `${hashString(key)}-${index}`);
+    }
     return path.join(this.dir, `${key}-${index}`);
   }
 

package/src/LMDBLiteCache.js

@@ -5,21 +5,23 @@ import {
   registerSerializableClass,
   serialize,
 } from '@atlaspack/build-cache';
+import {getFeatureFlag} from '@atlaspack/feature-flags';
 import {Lmdb} from '@atlaspack/rust';
 import type {FilePath} from '@atlaspack/types';
 import type {Cache} from './types';
 import type {Readable, Writable} from 'stream';
-
+import fs from 'fs';
+import ncp from 'ncp';
+import {promisify} from 'util';
 import stream from 'stream';
 import path from 'path';
-import {promisify} from 'util';
-
 import {NodeFS} from '@atlaspack/fs';
-
 // $FlowFixMe
 import packageJson from '../package.json';
-
 import {FSCache} from './FSCache';
+import {instrumentAsync} from '@atlaspack/logger';
+
+const ncpAsync = promisify(ncp);
 
 interface DBOpenOptions {
   name: string;
@@ -34,11 +36,14 @@ export class LmdbWrapper {
 
   constructor(lmdb: Lmdb) {
     this.lmdb = lmdb;
+  }
 
-    // $FlowFixMe
-    this[Symbol.dispose] = () => {
-      this.lmdb.close();
-    };
+  has(key: string): boolean {
+    return this.lmdb.hasSync(key);
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.lmdb.delete(key);
   }
 
   get(key: string): Buffer | null {
@@ -51,7 +56,21 @@ export class LmdbWrapper {
     await this.lmdb.put(key, buffer);
   }
 
-  resetReadTxn() {}
+  *keys(): Iterable<string> {
+    const PAGE_SIZE = 10000000;
+
+    let currentKeys = this.lmdb.keysSync(0, PAGE_SIZE);
+    while (currentKeys.length > 0) {
+      for (const key of currentKeys) {
+        yield key;
+      }
+      currentKeys = this.lmdb.keysSync(currentKeys.length, PAGE_SIZE);
+    }
+  }
+
+  compact(targetPath: string) {
+    this.lmdb.compact(targetPath);
+  }
 }
 
 export function open(
@@ -84,10 +103,15 @@ export class LMDBLiteCache implements Cache {
   dir: FilePath;
   store: LmdbWrapper;
   fsCache: FSCache;
+  /**
+   * Directory where we store raw files.
+   */
+  cacheFilesDirectory: FilePath;
 
   constructor(cacheDir: FilePath) {
     this.fs = new NodeFS();
     this.dir = cacheDir;
+    this.cacheFilesDirectory = path.join(cacheDir, 'files');
     this.fsCache = new FSCache(this.fs, cacheDir);
 
     this.store = open(cacheDir, {
@@ -105,7 +129,10 @@ export class LMDBLiteCache implements Cache {
   }
 
   async ensure(): Promise<void> {
-    await this.fsCache.ensure();
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      await this.fsCache.ensure();
+    }
+    await this.fs.mkdirp(this.cacheFilesDirectory);
     return Promise.resolve();
   }
 
@@ -120,7 +147,7 @@ export class LMDBLiteCache implements Cache {
   }
 
   has(key: string): Promise<boolean> {
-    return Promise.resolve(this.store.get(key) != null);
+    return Promise.resolve(this.store.has(key));
   }
 
   get<T>(key: string): Promise<?T> {
@@ -137,14 +164,24 @@ export class LMDBLiteCache implements Cache {
   }
 
   getStream(key: string): Readable {
-    return this.fs.createReadStream(path.join(this.dir, key));
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return this.fs.createReadStream(path.join(this.dir, key));
+    }
+
+    return fs.createReadStream(this.getFileKey(key));
   }
 
-  setStream(key: string, stream: Readable): Promise<void> {
-    return pipeline(
-      stream,
-      this.fs.createWriteStream(path.join(this.dir, key)),
-    );
+  async setStream(key: string, stream: Readable): Promise<void> {
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return pipeline(
+        stream,
+        this.fs.createWriteStream(path.join(this.dir, key)),
+      );
+    }
+
+    const filePath = this.getFileKey(key);
+    await fs.promises.mkdir(path.dirname(filePath), {recursive: true});
+    return pipeline(stream, fs.createWriteStream(filePath));
   }
 
   // eslint-disable-next-line require-await
@@ -168,38 +205,107 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(this.store.get(key));
   }
 
-  #getFilePath(key: string, index: number): string {
-    return path.join(this.dir, `${key}-${index}`);
-  }
-
   hasLargeBlob(key: string): Promise<boolean> {
-    return this.fs.exists(this.#getFilePath(key, 0));
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return this.fsCache.hasLargeBlob(key);
+    }
+
+    return fs.promises
+      .access(this.getFileKey(key), fs.constants.F_OK)
+      .then(() => true)
+      .catch(() => false);
   }
 
-  // eslint-disable-next-line require-await
-  async getLargeBlob(key: string): Promise<Buffer> {
-    return this.fsCache.getLargeBlob(key);
+  getLargeBlob(key: string): Promise<Buffer> {
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return this.fsCache.getLargeBlob(key);
+    }
+    return fs.promises.readFile(this.getFileKey(key));
   }
 
-  // eslint-disable-next-line require-await
   async setLargeBlob(
     key: string,
     contents: Buffer | string,
     options?: {|signal?: AbortSignal|},
   ): Promise<void> {
-    return this.fsCache.setLargeBlob(key, contents, options);
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return this.fsCache.setLargeBlob(key, contents, options);
+    }
+
+    const targetPath = this.getFileKey(key);
+    await fs.promises.mkdir(path.dirname(targetPath), {recursive: true});
+    return fs.promises.writeFile(targetPath, contents);
   }
 
+  /**
+   * @deprecated Use store.delete instead.
+   */
   deleteLargeBlob(key: string): Promise<void> {
-    return this.fsCache.deleteLargeBlob(key);
+    if (!getFeatureFlag('cachePerformanceImprovements')) {
+      return this.fsCache.deleteLargeBlob(key);
+    }
+
+    return this.store.delete(key);
+  }
+
+  keys(): Iterable<string> {
+    return this.store.keys();
+  }
+
+  async compact(targetPath: string): Promise<void> {
+    await fs.promises.mkdir(targetPath, {recursive: true});
+
+    const files = await fs.promises.readdir(this.dir);
+    // copy all files except data.mdb and lock.mdb to the target path (recursive)
+    for (const file of files) {
+      const filePath = path.join(this.dir, file);
+
+      if (file === 'data.mdb' || file === 'lock.mdb') {
+        continue;
+      }
+
+      await ncpAsync(filePath, path.join(targetPath, file));
+    }
+
+    this.store.compact(path.join(targetPath, 'data.mdb'));
   }
 
-  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();
+  refresh(): void {}
+
+  /**
+   * Streams, packages are stored in files instead of LMDB.
+   *
+   * On this case, if a cache key happens to have a parent traversal, ../..
+   * it is treated specially
+   *
+   * That is, something/../something and something are meant to be different
+   * keys.
+   *
+   * Plus we do not want to store values outside of the cache directory.
+   */
+  getFileKey(key: string): string {
+    const cleanKey = key
+      .split('/')
+      .map((part) => {
+        if (part === '..') {
+          return '$$__parent_dir$$';
+        }
+        return part;
+      })
+      .join('/');
+    return path.join(this.cacheFilesDirectory, cleanKey);
+  }
+
+  async clear(): Promise<void> {
+    await instrumentAsync('LMDBLiteCache::clear', async () => {
+      const keys = await this.keys();
+      for (const key of keys) {
+        await this.store.delete(key);
+      }
+
+      await this.fs.rimraf(this.cacheFilesDirectory);
+      await this.fs.mkdirp(this.cacheFilesDirectory);
+    });
   }
 }
 

package/src/index.js

@@ -2,7 +2,6 @@
 
 export * from './FSCache';
 export * from './IDBCache';
-export * from './LMDBCache';
 export * from './LMDBLiteCache';
 
 export type {Cache} from './types';

package/test/LMDBLiteCache.test.js

@@ -1,20 +1,30 @@
 // @flow
+
+import * as fs from 'fs';
 import * as path from 'path';
 import {tmpdir} from 'os';
 import {LMDBLiteCache} from '../src/index';
 import {deserialize, serialize} from 'v8';
 import assert from 'assert';
+import {Worker} from 'worker_threads';
+import {initializeMonitoring} from '@atlaspack/rust';
 
 const cacheDir = path.join(tmpdir(), 'lmdb-lite-cache-tests');
 
 describe('LMDBLiteCache', () => {
+  let cache;
+
+  beforeEach(async () => {
+    await fs.promises.rm(cacheDir, {recursive: true, force: true});
+  });
+
   it('can be constructed', async () => {
-    const cache = new LMDBLiteCache(cacheDir);
+    cache = new LMDBLiteCache(cacheDir);
     await cache.ensure();
   });
 
   it('can retrieve keys', async () => {
-    const cache = new LMDBLiteCache(cacheDir);
+    cache = new LMDBLiteCache(cacheDir);
     await cache.ensure();
     await cache.setBlob('key', Buffer.from(serialize({value: 42})));
     const buffer = await cache.getBlob('key');
@@ -23,11 +33,211 @@ describe('LMDBLiteCache', () => {
   });
 
   it('can retrieve keys synchronously', async () => {
-    const cache = new LMDBLiteCache(cacheDir);
+    cache = new LMDBLiteCache(path.join(cacheDir, 'retrieve_keys_test'));
     await cache.ensure();
-    cache.setBlob('key', Buffer.from(serialize({value: 42})));
+    await cache.setBlob('key', Buffer.from(serialize({value: 42})));
     const buffer = cache.getBlobSync('key');
     const result = deserialize(buffer);
     assert.equal(result.value, 42);
   });
+
+  it('can iterate over keys', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'keys_test'));
+    await cache.ensure();
+    await cache.setBlob('key1', Buffer.from(serialize({value: 42})));
+    await cache.setBlob('key2', Buffer.from(serialize({value: 43})));
+    const keys = cache.keys();
+    assert.deepEqual(Array.from(keys), ['key1', 'key2']);
+  });
+
+  it('can compact databases', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'compact_test'));
+    await cache.ensure();
+    await cache.setBlob('key1', Buffer.from(serialize({value: 42})));
+    await cache.setBlob('key2', Buffer.from(serialize({value: 43})));
+    await cache.compact(path.join(cacheDir, 'compact_test_compacted'));
+
+    cache = new LMDBLiteCache(path.join(cacheDir, 'compact_test_compacted'));
+    await cache.ensure();
+    const keys = cache.keys();
+    assert.deepEqual(Array.from(keys), ['key1', 'key2']);
+  });
+
+  describe('getFileKey', () => {
+    it('should return the correct key', () => {
+      const target = path.join(cacheDir, 'test-file-keys');
+      const cache = new LMDBLiteCache(target);
+      const key = cache.getFileKey('key');
+      assert.equal(key, path.join(target, 'files', 'key'));
+    });
+
+    it('should return the correct key for a key with a parent traversal', () => {
+      const target = path.join(cacheDir, 'test-parent-keys');
+      cache = new LMDBLiteCache(target);
+      const key = cache.getFileKey('../../key');
+      assert.equal(
+        key,
+        path.join(target, 'files', '$$__parent_dir$$/$$__parent_dir$$/key'),
+      );
+    });
+  });
+
+  it('can be closed and re-opened', async () => {
+    cache = new LMDBLiteCache(path.join(cacheDir, 'close_and_reopen_test'));
+    await cache.ensure();
+    await cache.setBlob('key', Buffer.from(serialize({value: 42})));
+    cache = new LMDBLiteCache(path.join(cacheDir, 'close_and_reopen_test'));
+    await cache.ensure();
+    const buffer = await cache.getBlob('key');
+    const result = deserialize(buffer);
+    assert.equal(result.value, 42);
+  });
+
+  it('should NOT fail when trying to open the same database twice', async () => {
+    const testDir = path.join(cacheDir, 'double_open_test');
+    const cache1 = new LMDBLiteCache(testDir);
+    await cache1.ensure();
+
+    assert.doesNotThrow(() => {
+      new LMDBLiteCache(testDir);
+    });
+  });
+
+  it('should NOT fail when trying to open after GC', async () => {
+    const testDir = path.join(cacheDir, 'gc_test');
+
+    let cache1 = new LMDBLiteCache(testDir);
+    await cache1.ensure();
+    await cache1.setBlob('key', Buffer.from(serialize({value: 42})));
+
+    cache1 = null;
+
+    if (global.gc) {
+      global.gc();
+    }
+
+    assert.doesNotThrow(() => {
+      new LMDBLiteCache(testDir);
+    });
+  });
+
+  it('should handle rapid open/close cycles', async () => {
+    const testDir = path.join(cacheDir, 'rapid_cycles_test');
+
+    for (let i = 0; i < 10; i++) {
+      const cache = new LMDBLiteCache(testDir);
+      await cache.ensure();
+      await cache.setBlob(`key${i}`, Buffer.from(serialize({value: i})));
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+
+    const finalCache = new LMDBLiteCache(testDir);
+    await finalCache.ensure();
+    const buffer = await finalCache.getBlob('key9');
+    const result = deserialize(buffer);
+    assert.equal(result.value, 9);
+  });
+
+  it('should work when there are multiple node.js worker threads accessing the same database', async function () {
+    this.timeout(40000);
+
+    try {
+      initializeMonitoring();
+    } catch (error) {
+      /* empty */
+    }
+
+    const testDir = path.join(cacheDir, 'worker_threads_test');
+
+    let cache = new LMDBLiteCache(testDir);
+    await cache.set('main_thread_key', {
+      mainThreadId: 0,
+      hello: 'world',
+    });
+    setTimeout(() => {
+      cache = null;
+
+      if (global.gc) {
+        global.gc();
+      }
+    }, Math.random() * 300);
+
+    const numWorkers = 10;
+
+    const workers = [];
+    const responsePromises = [];
+    for (let i = 0; i < numWorkers; i++) {
+      const worker = new Worker(path.join(__dirname, 'workerThreadsTest.js'), {
+        workerData: {
+          cacheDir: testDir,
+        },
+      });
+      workers.push(worker);
+
+      const responsePromise = new Promise((resolve, reject) => {
+        worker.addListener('error', (error: Error) => {
+          reject(error);
+        });
+        worker.addListener('message', (message) => {
+          resolve(message);
+        });
+      });
+
+      worker.addListener('message', (message) => {
+        // eslint-disable-next-line no-console
+        console.log('Worker message', message);
+      });
+      worker.addListener('online', () => {
+        worker.postMessage({
+          type: 'go',
+        });
+      });
+
+      responsePromises.push(responsePromise);
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('Waiting for responses');
+    const responses = await Promise.all(responsePromises);
+
+    // eslint-disable-next-line no-console
+    console.log('Responses received');
+    for (const [index, response] of responses.entries()) {
+      const worker = workers[index];
+
+      assert.deepEqual(
+        response,
+        {
+          mainThreadData: {
+            mainThreadId: 0,
+            hello: 'world',
+          },
+          workerId: worker.threadId,
+        },
+        `worker_${index} - Worker ${worker.threadId} should have received the correct data`,
+      );
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('Getting main thread key');
+    cache = new LMDBLiteCache(testDir);
+    const data = await cache?.get('main_thread_key');
+    assert.deepEqual(data, {
+      mainThreadId: 0,
+      hello: 'world',
+    });
+
+    // eslint-disable-next-line no-console
+    console.log('Getting worker keys');
+    for (const worker of workers) {
+      const data = await cache?.get(`worker_key/${worker.threadId}`);
+      assert.deepEqual(data, {
+        workerId: worker.threadId,
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      worker.terminate();
+    }
+  });
 });

package/test/workerThreadsTest.js

@@ -0,0 +1,42 @@
+/* eslint-disable no-inner-declarations */
+
+require('@atlaspack/babel-register');
+const {
+  workerData,
+  threadId,
+  parentPort,
+  isMainThread,
+} = require('worker_threads');
+const {LMDBLiteCache} = require('../src/index');
+
+if (!isMainThread) {
+  const cache = new LMDBLiteCache(workerData.cacheDir);
+
+  async function onMessage() {
+    try {
+      cache.set(`worker_key/${threadId}`, {
+        workerId: threadId,
+      });
+
+      const data = await cache.get('main_thread_key');
+
+      parentPort.postMessage({
+        mainThreadData: data,
+        workerId: threadId,
+      });
+
+      setTimeout(() => {
+        parentPort.postMessage({
+          type: 'close',
+          workerId: threadId,
+        });
+      }, Math.random() * 200);
+    } catch (error) {
+      parentPort.postMessage({
+        error: error.message,
+      });
+    }
+  }
+
+  parentPort.on('message', onMessage);
+}

package/lib/LMDBCache.js

@@ -1,136 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.LMDBCache = void 0;
-function _stream() {
-  const data = _interopRequireDefault(require("stream"));
-  _stream = function () {
-    return data;
-  };
-  return data;
-}
-function _path() {
-  const data = _interopRequireDefault(require("path"));
-  _path = function () {
-    return data;
-  };
-  return data;
-}
-function _util() {
-  const data = require("util");
-  _util = function () {
-    return data;
-  };
-  return data;
-}
-function _buildCache() {
-  const data = require("@atlaspack/build-cache");
-  _buildCache = function () {
-    return data;
-  };
-  return data;
-}
-function _fs() {
-  const data = require("@atlaspack/fs");
-  _fs = function () {
-    return data;
-  };
-  return data;
-}
-function _lmdb() {
-  const data = _interopRequireDefault(require("lmdb"));
-  _lmdb = function () {
-    return data;
-  };
-  return data;
-}
-var _package = _interopRequireDefault(require("../package.json"));
-var _FSCache = require("./FSCache");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// flowlint-next-line untyped-import:off
-// $FlowFixMe
-const pipeline = (0, _util().promisify)(_stream().default.pipeline);
-class LMDBCache {
-  // $FlowFixMe
-
-  constructor(cacheDir) {
-    this.fs = new (_fs().NodeFS)();
-    this.dir = cacheDir;
-    this.fsCache = new _FSCache.FSCache(this.fs, cacheDir);
-    this.store = _lmdb().default.open(cacheDir, {
-      name: 'parcel-cache',
-      encoding: 'binary',
-      compression: true
-    });
-  }
-  ensure() {
-    return Promise.resolve();
-  }
-  serialize() {
-    return {
-      dir: this.dir
-    };
-  }
-  static deserialize(opts) {
-    return new LMDBCache(opts.dir);
-  }
-  has(key) {
-    return Promise.resolve(this.store.get(key) != null);
-  }
-  get(key) {
-    let data = this.store.get(key);
-    if (data == null) {
-      return Promise.resolve(null);
-    }
-    return Promise.resolve((0, _buildCache().deserialize)(data));
-  }
-  async set(key, value) {
-    await this.setBlob(key, (0, _buildCache().serialize)(value));
-  }
-  getStream(key) {
-    return this.fs.createReadStream(_path().default.join(this.dir, key));
-  }
-  setStream(key, stream) {
-    return pipeline(stream, this.fs.createWriteStream(_path().default.join(this.dir, key)));
-  }
-  getBlob(key) {
-    let buffer = this.store.get(key);
-    return buffer != null ? Promise.resolve(buffer) : Promise.reject(new Error(`Key ${key} not found in cache`));
-  }
-  async setBlob(key, contents) {
-    await this.store.put(key, contents);
-  }
-  getBuffer(key) {
-    return Promise.resolve(this.store.get(key));
-  }
-  #getFilePath(key, index) {
-    return _path().default.join(this.dir, `${key}-${index}`);
-  }
-  hasLargeBlob(key) {
-    return this.fs.exists(this.#getFilePath(key, 0));
-  }
-
-  // eslint-disable-next-line require-await
-  async getLargeBlob(key) {
-    return this.fsCache.getLargeBlob(key);
-  }
-
-  // eslint-disable-next-line require-await
-  async setLargeBlob(key, contents, options) {
-    return this.fsCache.setLargeBlob(key, contents, options);
-  }
-  deleteLargeBlob(key) {
-    return this.fsCache.deleteLargeBlob(key);
-  }
-  refresh() {
-    // 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();
-  }
-}
-exports.LMDBCache = LMDBCache;
-(0, _buildCache().registerSerializableClass)(`${_package.default.version}:LMDBCache`, LMDBCache);

package/src/LMDBCache.js

@@ -1,139 +0,0 @@
-// @flow strict-local
-import type {FilePath} from '@atlaspack/types';
-import type {Cache} from './types';
-import type {Readable, Writable} from 'stream';
-
-import stream from 'stream';
-import path from 'path';
-import {promisify} from 'util';
-
-import {
-  deserialize,
-  registerSerializableClass,
-  serialize,
-} from '@atlaspack/build-cache';
-import {NodeFS} from '@atlaspack/fs';
-// flowlint-next-line untyped-import:off
-import lmdb from 'lmdb';
-
-// $FlowFixMe
-import packageJson from '../package.json';
-
-import {FSCache} from './FSCache';
-
-const pipeline: (Readable, Writable) => Promise<void> = promisify(
-  stream.pipeline,
-);
-
-export class LMDBCache implements Cache {
-  fs: NodeFS;
-  dir: FilePath;
-  // $FlowFixMe
-  store: any;
-  fsCache: FSCache;
-
-  constructor(cacheDir: FilePath) {
-    this.fs = new NodeFS();
-    this.dir = cacheDir;
-    this.fsCache = new FSCache(this.fs, cacheDir);
-
-    this.store = lmdb.open(cacheDir, {
-      name: 'parcel-cache',
-      encoding: 'binary',
-      compression: true,
-    });
-  }
-
-  ensure(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  serialize(): {|dir: FilePath|} {
-    return {
-      dir: this.dir,
-    };
-  }
-
-  static deserialize(opts: {|dir: FilePath|}): LMDBCache {
-    return new LMDBCache(opts.dir);
-  }
-
-  has(key: string): Promise<boolean> {
-    return Promise.resolve(this.store.get(key) != null);
-  }
-
-  get<T>(key: string): Promise<?T> {
-    let data = this.store.get(key);
-    if (data == null) {
-      return Promise.resolve(null);
-    }
-
-    return Promise.resolve(deserialize(data));
-  }
-
-  async set(key: string, value: mixed): Promise<void> {
-    await this.setBlob(key, serialize(value));
-  }
-
-  getStream(key: string): Readable {
-    return this.fs.createReadStream(path.join(this.dir, key));
-  }
-
-  setStream(key: string, stream: Readable): Promise<void> {
-    return pipeline(
-      stream,
-      this.fs.createWriteStream(path.join(this.dir, key)),
-    );
-  }
-
-  getBlob(key: string): Promise<Buffer> {
-    let buffer = this.store.get(key);
-    return buffer != null
-      ? Promise.resolve(buffer)
-      : Promise.reject(new Error(`Key ${key} not found in cache`));
-  }
-
-  async setBlob(key: string, contents: Buffer | string): Promise<void> {
-    await this.store.put(key, contents);
-  }
-
-  getBuffer(key: string): Promise<?Buffer> {
-    return Promise.resolve(this.store.get(key));
-  }
-
-  #getFilePath(key: string, index: number): string {
-    return path.join(this.dir, `${key}-${index}`);
-  }
-
-  hasLargeBlob(key: string): Promise<boolean> {
-    return this.fs.exists(this.#getFilePath(key, 0));
-  }
-
-  // eslint-disable-next-line require-await
-  async getLargeBlob(key: string): Promise<Buffer> {
-    return this.fsCache.getLargeBlob(key);
-  }
-
-  // eslint-disable-next-line require-await
-  async setLargeBlob(
-    key: string,
-    contents: Buffer | string,
-    options?: {|signal?: AbortSignal|},
-  ): Promise<void> {
-    return this.fsCache.setLargeBlob(key, contents, options);
-  }
-
-  deleteLargeBlob(key: string): Promise<void> {
-    return this.fsCache.deleteLargeBlob(key);
-  }
-
-  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);